Explore Projects

This project aims to enable many authentication frameworks and add support for an authentication layer to Glee. This will give developers the ability to use Glee to create secure online applications with a variety of authentication choices. To accommodate future additions of new authentication frameworks, the authentication layer will be created to be modular and adaptable. After this project, when using Glee to build a server, the developer should be able to specify the authentication strategy they wish to support. Token-based authentication: This could be done using the jsonwebtoken npm package, provision will be made for both refresh and access tokens. Access tokens will be short-lived tokens, while refresh tokens will have longer life spans and allow for renewal of the access tokens. Basic authentication: This authentication strategy would be implemented from scratch. Certificate-based authentication: certificate-based authentication will be implemented from scratch. OAuth 2.0 authentication: OAuth 2.0 authentication will be achieved using the node-oauth2-server npm package. Session-based authentication: The viable option here will be to build the session-based authentication from scratch, as many of the options available such as passport-session, express-session, and fastify/session are all framework dependent.

OWTF right now has a fixed set of plugins. If a security researcher wants to add a new tool or technique, there is no way to do it without touching the core codebase. Plugins also run inside the main OWTF process, which means one bad plugin can crash the whole system. There is no isolation, no sandboxing and no way for the community to contribute plugins. I am planning to fix this by building a simple plugin ecosystem. First, an upload API where users can submit a .py file with metadata. Before saving, a validator checks the code and blocks unsafe things like eval, exec, file writes or socket access. Safe plugins get stored with a pending review status. Second, sandboxed execution. I will run each plugin in an isolated process with limits on CPU, memory, and time and plug this into the existing plugin manager so it works seamlessly. Third, plugin discovery. I will add a /plugins endpoint and a small marketplace UI where users can browse, filter, install and run approved plugins easily. Deliverables: PluginValidator module, SandboxRunner module, UserPlugin database model and migration, upload and listing API endpoints, Plugin Marketplace UI with browse and upload pages, Nuclei plugin as reference implementation, unit and integration tests and a plugin authoring guide.

Sugar's Journal records everything a child creates, but reflection one of its three core design pillars amounts to an empty text box that most children never touch. There is no prompt, no conversation, no mechanism to surface what a child learned from what they made. This project adds that mechanism by embedding a conversational reflection panel directly in the Journal, powered by the existing Sugar-AI backend. When a child opens a Journal entry, A reflection buddy asks a single artifact grounded question rooted in constructionist pedagogy. The conversation is adaptive, capped, and never forced. A gentle non-blocking nudge on activity exit reminds children that Reflection Buddy is ready without interrupting their workflow. What a child says they want to try next is saved and surfaced at the start of their next session, closing the loop from Reflect back to Imagine. Offline deployments are covered by Reflection Sparks, a curated bank of static prompts. Deliverables: 1. 2 FastAPI endpoints integrated into Sugar-AI (/reflect/chat and /reflect/summary) 2. A GTK3 reflection panel embedded in the Journal view 3. Metadata persistence via D-Bus 4. A feed-forward banner 5. An offline fallback 6. Full test coverage, working across all 40+ Sugar activities without activity-specific configuration.

<p>Implementing an <strong>in-proxy authorization cache for envoy proxy using web assembly and proxy-WASM rust SDK</strong>. The cache will be in synchronization with 3scale Service Management API by periodically flushing the local cache snapshot and updating the local cache with a new cache snapshot provided by 3scale Service Management API. When a HTTP request is received by the proxy, it will do a look up in the cache to check whether a cache record exist for that particular request. If a record exist, then perform authorization logic based on that request <strong>(cache hit)</strong> . If a cache record does not exist<strong>(cache miss)</strong>, do a HTTP call to 3scale Service Management API to fetch relevant authorization data, add the records to the local cache for any subsequent requests and perform authorization based on the received data. For the project, <strong>a request intercepting HTTP filter</strong> and a <strong>singleton service that runs independently from request life cycle</strong> will be implemented using proxy-wasm-rust-sdk and will compile them as web assembly modules to extend envoy proxy with the HTTP filter and singleton. <strong>Web assembly modules allow us to extend envoy without building the envoy static binary using bazel build system.</strong></p>

@nightwatch/mobile-helper is a tool that allows developers and testers to set up a fully functional Android Emulator environment in just a few minutes, without the need to download the complete Android Studio IDE software. This tool comes in very handy, especially for testers who wish to perform end-to-end tests for their website or native app on Android Emulators, by allowing them to set up everything they need in under 5 minutes, as opposed to having to set up the hefty Android Studio IDE and figuring everything out themselves.This project aims to take this tool one step further, by building on its usability and allowing users to do much more with the tool such that it not only benefits the testers but the developer community as a whole, or anyone who wish to quickly set up Android Emulators on their machines, while only downloading what is necessary, saving both internet bandwidth and storage capacity. To achieve this, this project proposes: a) Adding support for wireless adb connection to avoid the inconvenience of using USB cable. Users will be able to connect and manage multiple devices, both real and emulator. b) Adding support for downloading and managing multiple system images and emulators to facilitate use of a wider range of emulator devices. c) Adding functionality to update the installed SDK tools. d) Document all important SDK commands for easy accessibility of the users. The tool will help users to perform all these tasks with a very interactive and easy to use command line interface.

JBoss Web Server (JWS) is Red Hat’s enterprise distribution of Apache Tomcat used in production environments where configuration correctness and operational visibility are critical. Many production incidents are caused by configuration errors such as TLS misconfiguration, incorrect connector exposure, proxy misconfiguration, permission issues, and environment drift rather than software defects. This project proposes jws-diag, a read-only Java CLI diagnostic tool designed to help operators and support engineers quickly understand installation state, effective runtime configuration, and potential configuration risks. The tool will provide: • Installation and runtime summary (JWS/Tomcat versions, JVM, OS, container signals) • Effective configuration parsing from server.xml with defaults resolution • Validation rules engine producing INFO/WARN/ERROR findings • Comprehensive test suite with configuration fixtures • Documentation and operational usage guidance • Optional redacted support bundle generation (stretch goal) Key deliverables include: • jws-diag summary command • jws-diag config command • jws-diag validate command with validation rules • Test suite and documentation • Integration into JWS ecosystem tooling The project will initially target: JWS 6 and JWS 7 Tomcat 10.1 and Tomcat 11 The expected outcome is a production-safe diagnostic tool that improves troubleshooting efficiency and configuration reliability for JBoss Web Server deployments.

This project aims to modernize the Speak Activity by integrating a large language model (LLM) & small language model (SLM) to enhance the chatbot and integrate a modern TTS model to improve the voice features, making it more educational and engaging for early learners. The Speak Activity, traditionally used for promoting reading skills through synthetic speech, will be upgraded to provide a more natural and interactive experience. The primary objective is to implement an LLM-based chatbot offering improved conversational abilities and a more human-like interaction style. For the voice feature a high-quality, natural-sounding Text-to-Speech (TTS) model that accurately handles pronunciation and phonetics will be used. By fine-tuning the LLM to manage invented spelling and grammatical inaccuracies, the chatbot will offer a supportive and child-friendly interaction, guiding learners in an encouraging manner. The project will utilize Python and a fine-tuned model hosted on the cloud and accessed via an API endpoint. This design ensures compatibility and seamless integration with the existing Speak Activity, without adding extra dependencies. To support offline functionality, a lightweight, fine-tuned fallback model will be packaged with the activity. This fallback ensures continued usability even without an internet connection, albeit with slightly less accurate responses compared to the cloud-hosted model. This enhancement will make the Speak Activity a more effective and child-friendly tool, promoting better language learning through engaging and conversational interactions.

Joplin users accumulate hundreds of notes over time, but existing graph plugins only visualize explicit links (:/noteId) and shared tags, leaving semantically related yet unlinked notes disconnected. This project introduces an AI-powered Joplin plugin that uncovers these hidden relationships using text embeddings as the primary mechanism, with optional LLM-based enrichment for labeling and categorization. The default embedding provider is Transformers.js, enabling fully local, zero-setup inference with no external dependencies, while advanced users can opt into Ollama, Google Gemini, OpenAI, or compatible APIs. The system combines explicit links, tag relationships, and embedding-based semantic similarity into a unified graph, ensuring comprehensive note connectivity. The plugin renders this enriched structure as an interactive graph using Cytoscape.js with the fCoSE layout, where node size reflects centrality, node color represents Louvain-detected communities, and edge styles distinguish relationship types (solid for links, dotted for tags, dashed for semantic connections). It includes features such as click-to-navigate, focus mode, filtering, and export to PNG/SVG/JSON. A SQLite-based cache stores embeddings for incremental updates, ensuring scalability and performance, while optional Pass B LLM enrichment adds human-readable relationship labels and categories. The final deliverable is a production-ready .jpl plugin with secure API key handling, provider abstraction, and a comprehensive test suite including deterministic validation of AI outputs.

Joplin's offline-first design is one of its best features, but it comes with a real cost when the same note is edited on two devices before either syncs, Joplin has no way to merge the changes. It saves one version as a conflict note and leaves the user to manually figure out what to keep. For long notes on mobile, most people just give up and pick whichever version looks more complete, which means changes get silently lost. This project adds an interactive conflict resolution UI to Joplin desktop and mobile. When a conflict note is opened, instead of seeing a raw copy with no context, the user gets a clear section-by-section view of exactly what each side changed. Non-conflicting changes like additions and deletions can be resolved in one click. Genuine conflicts where both sides changed the same part give the user full context to pick one side or edit manually. A Keep both option preserves both versions for users who want that. The same shared diff module powers both platforms so the behaviour is always identical. The core deliverables are a platform-independent diff module using node-diff3, a minimal addition to the sync pipeline to store a base snapshot for three-way merging, and a conflict resolution React component for desktop and React Native component for mobile. The implementation also handles edge cases including notes synced before the feature was deployed falling back to two-way diff, stale remote data being detected and reset on open, and second conflicts on the same note being handled gracefully. No existing conflict behaviour changes and sync is never blocked at any point.

Sugar Activity on Demand addresses a key barrier in Sugar Labs: the difficulty learners face in creating their own activities due to the need for programming knowledge. This limits access to constructionist learning, where students learn best by building meaningful projects. This project introduces an AI-assisted system that allows learners to describe an activity in natural language and receive a fully functional, installable Sugar activity. The system combines a model-agnostic LLM pipeline, a retrieval-augmented knowledge base built from real Sugar Activity source code, and an AST-based validator to ensure that generated Python code is both correct and safe. Activities are generated with proper GTK3 interfaces, toolbar integration, and Journal support, ensuring they are fully compatible with the Sugar ecosystem. Beyond generation, the project emphasizes learning through a Reflective Studio, where learners explore, understand, and modify the generated code. Using scaffolded challenges, inline annotations, and reflection prompts, the system follows the constructionist Use → Modify → Create progression, enabling learners to gradually take ownership of their creations rather than passively consuming generated output. Deliverables AI-powered activity generation pipeline (prompt → plan → code → installable bundle) RAG-based knowledge system using real Sugar Activity examples AST-based security validation and safe code generation framework Interactive Reflective Studio with guided editing, annotations, and challenges Integration into Sugar’s Home View with a seamless “Create with AI” entry point Support for iterative refinement, version history, and sharing via the Sugar Journal This project aligns with Sugar Labs’ constructionist philosophy by transforming AI from a passive generator into an active learning partner, empowering learners not just to use software, but to understand and create it.

The Sugarizer Human Activity Pack project aims to enhance the educational tools provided by Sugar Labs by developing two engaging and interactive activities. The first, the 3D Human Body Activity, will expand on the existing anatomical visualization tool by integrating multiple 3D models, including skeletal, human body and organ system. It will allow users to toggle between different layers, interact with body structures dynamically, and engage in real-time collaborative learning. Additional features such as interactive quizzes, UI/UX refinements, and localization support will ensure accessibility and usability across different regions and devices. The second component, the Stickman Animation Activity, will introduce an interactive keyframe animation tool where users can manipulate a stick figure by adjusting its nodes to create animations. This tool will support essential animation features such as playback, speed control, and exporting animations as videos. It will also include a collection of pre-designed templates for common movements like running, jumping, and dancing. A standout feature of this activity is the ability to import a photo of a human body and generate a corresponding stick figure in the same pose using AI-assisted pose detection. By the end of the project, Sugar Labs will gain two fully functional, optimized, and localized activities that provide immersive learning experiences in human anatomy and animation principles. The enhancements to the 3D Human Body Activity will enable students to explore anatomy in a more interactive and engaging way, moving beyond static textbook images to dynamic 3D models. The Stickman Animation Activity will encourage creativity and spatial understanding by allowing students to experiment with motion and animation concepts. Together, these activities will significantly contribute to making education more engaging, interactive, and widely accessible.

Customizable Node.js API framework with auto-generated REST and GraphQL endpoints.

<p>My proposal is for the modernization of the Web UI of VLC player using Vue.js</p>

Lightweight, fast API testing environment supporting HTTP, GraphQL, WebSockets, and Server-Sent Events.

Design and build a real-time peer mentorship matching room using WebRTC and Node.js WebSockets.

Build an inspection module for debugging asynchronous streaming boundaries and streaming chunk latencies in modern React frameworks.

<p>This projects aims at optimizing the storage capabilities on XO, adding improvements to the Sugar UI and adding offline support to InfoSlicer and GetBooks activities.</p>

<p>Provide support for retrieving image information from selected providers through their public APIs to increase the material available via CC Search and the CC Catalog API.</p>

<p>The aim of my project is to make the VLC app incorporate new iOS APIs and to make it more accessible for enabling application wide support of Voice Control, Voice over and more.</p>

<p>DotPlot is a web platform which enables users with little or no programming skills create data visualisations. The platform utilises D3.js JavaScript library wrapped in an easy to use interface.</p>

This project proposes to design and implement authoring support for six priority QTI 3.0 interaction types across the Studio stack. Every interaction this project produces will be renderable by any QTI-compliant platform.

The idea is to add thumbnail preview on the UI while seeking. Tasks to be accomplished include: extend the preparser to take snapshot of a video every few minutes/seconds, and adding qt and/or macOS support: display the snapshot taken by the prepaser while seeking.

This proposal defies the roadmap that i am going to follow for adding search&query, REST API, duplicates and reactive API support as well as implementing a Quarkus extension of Infinispan. I created some sub-tasks with estimation of hours for each to give clearer guidance.