Joplin

Mentors: Student: yugalkaushik

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.

Mentors: Student: Harsh16gupta

The more notes you accumulate, the harder it gets to keep them organised. At some point, manually tagging things or deciding which notebook something belongs to just stops happening and things pile up. What I'm building is a plugin that handles that quietly in the background. It analyses your notes, figures out which ones are about similar things, and suggests tags and notebook structures that reflect what's actually in your collection. You review the suggestions, pick what makes sense, and apply them. Nothing changes without you saying so. The deliverables are the plugin, the embedding and clustering pipeline, the recommendation system, and the review UI.

Mentors: Student: Keshav0479

Joplin’s end-to-end encryption protects notes during sync, but not on the local device. This project adds local note encryption so users can lock sensitive notes behind a vault password while preserving compatibility with sync and existing E2EE. The implementation will use an option-gated save/load flow, on-demand decryption, protection against plaintext leaks through search and revision history, and a lock screen UI for desktop. Guaranteed deliverables are a working desktop implementation, vault password management, sync/backward-compatibility support, and tests for data-safety and conflict handling. Stretch goals include mobile support, resource encryption, and CLI/Data API integration.

Mentors: Student: Akshaj Rawat

Problem: Joplin’s End-to-End Encryption (E2EE) secures data during sync, but notes remain in plaintext within the local SQLite database. This leaves sensitive data vulnerable to local filesystem access on shared, corporate, or unlocked devices. Solution: This project implements a Local Encrypted Vault using a "Body-Prefix Polymorphism" strategy. Instead of fragile database schema migrations, notes are locked via AES-256-GCM, and the ciphertext is stored directly in the native body field (e.g., JOPLIN_CIPHER:AF82D...). This architecture natively supports Joplin’s Stacked E2EE sync, prevents double-encryption bugs, and utilizes Just-In-Time (JIT) RAM decryption to ensure maximum security.

Mentors: Student: Sriram Varun Kumar

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.