Skip to content
RGiskard7Public

About

Local-first knowledge management app with Markdown notes, wiki-links, backlinks, Canvas, Kanban, interactive graphs, plugins, themes, and SQLite or Markdown vault storage.

Topics

Resources

Stars

34 stars

Watchers

1 watching

Forks

Latest commit

 

History

303 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Jylos

Español | English
Jylos Banner

License: MIT Version Java JavaFX SQLite Maven Platform

Local-first desktop knowledge management: Markdown notes, wiki-links, backlinks, an interactive knowledge graph, Kanban, canvas files, per-note encryption, plugins, and SQLite or Markdown-vault storage.

Download

Prebuilt packages for all major platforms are available on the Releases page:

  • Windows — .exe installer, .msi installer, portable ZIP
  • Linux — DEB/RPM (via jpackage), .pkg.tar.zst for Arch Linux (pacman), and a Nix flake for Nix/NixOS (nix run "github:RGiskard7/jylos?dir=packaging/nix", x86_64)
  • macOS — .dmg installer for Apple Silicon; on Intel Macs use JBang or build from source
  • Linux x64 — uber-JAR (requires Java 21). It bundles JavaFX for Linux only: on other systems use JBang, which adds JavaFX for yours
  • Via JBang — single command, no build needed:
    jbang jylos@RGiskard7/jylos
    JBang automatically downloads Java 21 and the JavaFX modules if needed.

Table of Contents

Why Jylos

Jylos is a local-first knowledge-management application: Markdown notes, wiki-links, backlinks, an interactive knowledge graph, a Kanban board, optional per-note encryption, a plugin system, and your choice of SQLite or a plain Markdown vault on disk.

The workflows popularized by Obsidian — wiki-links, backlinks, graph navigation — were a direct inspiration, and users already comfortable with that style of note-taking will feel at home from day one. Jylos is, however, an independent application: its own Java/JavaFX codebase, its own storage model (SQLite or raw Markdown vault), its own plugin architecture, and its own design decisions. It is open-source and MIT-licensed. Use whatever tool fits your workflow best.

In concrete terms:

  • Local-first and offline — your notes are plain .md files (vault mode) or a single SQLite database; you own the data, no cloud backend, no account, no telemetry.
  • A focused desktop app — single-user, written in Java/JavaFX, runs on Windows, macOS and Linux.
  • Free and MIT-licensed — an open-source project for the community.

Overview

Jylos is a Java 21 + JavaFX 23 desktop application inspired by Obsidian-like workflows:

  • CodeMirror 6 Markdown editor with Live Preview by default, a dedicated reading view, optional source mode and a linked side-by-side reading view (GFM, KaTeX math, emoji)
  • Two layouts: an Explorer tree with folders and notes together, in the style of Obsidian, or the classic folders | notes | editor columns (side by side or stacked). Pick one from the toolbar's layout button or in Preferences
  • Tabs that work like VS Code: a click opens the note in the current tab; Cmd/Ctrl+click, middle click or "Open in new tab" opens another. The graph and Kanban boards open in tabs too, and Jylos reopens your last session on start
  • Folder hierarchy + tags + favorites + recent + trash
  • Obsidian-compatible internal links ([[wiki-links]], [label](note.md)) with click-to-open in preview
  • Knowledge graph (global vault view or local neighbourhood around the open note)
  • Links panel: linked mentions, unlinked mentions (one click turns them into links) and outgoing links of the open note
  • Templates as in Obsidian, with optional Templater syntax, a daily note, and per-vault settings in Preferences → Vault
  • Shares a vault with Obsidian: Jylos writes nothing of its own into your notes, keeps properties as they were written, and can take Obsidian's template, daily-note and Templater settings and bookmarks (it only reads .obsidian)
  • Kanban board stored inside a note, and a distraction-free focus / writing mode
  • Canvas editor: open and edit Obsidian-compatible .canvas files on an infinite, pan/zoom surface — create/move/resize/colour text, link and group nodes, connect and delete edges (with arrowheads), and create new canvases; saves round-trip safely (unknown fields preserved)
  • Private notes: optional AES-256 body encryption behind a master password, with per-note or global unlock and delete protection
  • Command palette (Ctrl+P) and quick switcher (Ctrl+O)
  • External plugins (JARs in jylos/plugins/, built from plugins-source/) and themes (themes/ → jylos/themes/)
  • Storage: SQLite (default) or filesystem Markdown vault (.md + YAML frontmatter; optional Git menu for commit/stage/sync)

Features

Core

  • Create, edit, save, delete, and restore notes
  • Hierarchical folders and subfolders
  • Explorer layout: one tree with folders and notes, read folder by folder as you expand it; a filter that searches names across the whole vault (case and accents ignored), note order by name, edit or creation date, and a button to show the open note in the tree. The notes panel only appears for search and tag results
  • New tab page (Ctrl/Cmd+T) with new note, new canvas, go to file, graph and Kanban
  • Workspaces as contexts: the status bar shows the workspace in use and switches, saves or manages them; the last session (tabs and their back/forward history) comes back on start
  • Tags with assignment/removal workflows (SQLite and vault modes)
  • Favorites and recent notes
  • Trash with restore for notes and nested folders
  • Full-text search across note titles and bodies (with navigation from results)
  • Sorting and list/grid note views (title, preview lines, dates) in the classic layout

Editor & Preview

  • Markdown editor built on an offline CodeMirror 6 bundle, with theme-aware syntax highlighting, source/Live Preview presentation, selection, undo/redo, search/replace, clipboard actions, context menu, and [[ autocomplete
  • Tabs like VS Code: a click replaces the note in the current tab, an already open note switches to its tab, and Cmd/Ctrl+click, middle click or the context menu open a new tab ("Always open notes in a new tab" in Preferences restores one tab per note)
  • Save state and editor mode in the status bar: "Saved" / "Unsaved" (the tooltip says how often autosave runs) and the current mode, which opens a menu to switch between Live Preview, source, reading and linked reading
  • [[ autocomplete for note titles (accents and case ignored, best matches first); a foldable formatting toolbar (bold, lists, links, …)
  • Properties behind a button in the note header, in editing and reading; links in properties (up: "[[Index]]") count in the graph and backlinks
  • Colour emoji in the editor, reading view and PDF, and WebP images
  • Source-backed Live Preview shows each element rendered and only reveals the Markdown of the element under the cursor (headings, quotes and lists per line), all rendered while the editor is not focused, while preserving one editable document and one undo history. It draws callouts and notes embedded on their own line as in the reading view, images embedded with ![[…]], math with the bundled KaTeX, footnotes as numbers, clickable #tags (Cmd/Ctrl+click), dimmed %%comments%% and block ids, and the language of each code block; nothing is rendered inside code
  • A single book/pencil action switches between editing and reading; source mode is configurable in Preferences, while the linked side-by-side reading view is an independent View command
  • The separate reading view remains the canonical full render for transclusions, KaTeX and preview plugins
  • Markdown rendering with GFM tables, autolinks, strikethrough; code-block highlighting in preview (highlight.js)
  • KaTeX for $…$, $$…$$, and LaTeX delimiters (offline assets bundled in the JAR)
  • Emoji in preview via rasterized glyphs (reliable in the JavaFX WebView)
  • Wiki-link resolution shared with the graph and backlinks (WikiLinkResolver)
  • Transclusion / embeds: ![[Note]] (or ![[Note#Heading]], or a single block with ![[Note#^id]]) embeds another note's rendered content inline in the preview, with a click-to-open header; bounded recursion with cycle detection
  • Obsidian syntax in the reading view: callouts (> [!tip] Title, foldable with +/-), ==highlight==, hidden %%comments%%, footnotes ([^1] and inline ^[…]), block ids (^id) that [[Note#^id]] links and embeds point to, and clickable #tags that list the notes with that tag; none of it applies inside code. Links to a heading or block open the note there, and [[#Heading]] jumps within the note
  • Rich links: paste a URL to insert it as a visual card (title, description, thumbnail, site) — metadata fetched in the background; external links open in the system browser
  • Focus / writing mode (Ctrl/Cmd+Shift+F): hides everything but the editor
  • Split-pane proportions are remembered between sessions

Task board (Kanban)

  • A board is a normal note whose Markdown body holds columns (## Heading) and text cards (- card), in the spirit of Obsidian's Kanban plugin
  • Open with View → Kanban Board or Ctrl/Cmd+K; pick or create boards from the toolbar
  • Add/rename/delete columns, create/edit/delete cards, and drag cards between columns
  • A card can link to a note ([[Title]]) or be converted into a note
  • Per-column WIP limits ([wip=N], count badge turns red when exceeded) and colors ([color=#rrggbb]) — both stored in the heading line, set from the column menu
  • Cards referencing an image or PDF (![…](file.png), [[scan.pdf]]) show an embedded thumbnail (first PDF page via PDFBox)

Private notes (encryption)

  • Mark a note as private to encrypt only its body at rest (AES-256-GCM) — from Tools → Make Note Private/Public (Ctrl/Cmd+Shift+L) or the note's right-click menu
  • A single master password protects them (PBKDF2-derived key; the password itself is never stored). Opening one locked note prompts to unlock just that note; Tools → Unlock Private Notes reveals all of them, and Lock Private Notes locks again
  • A lock badge marks private notes in the list and the editor (closed = locked, open = readable this session)
  • Private notes are protected from deletion and export — turn a note normal first
  • Works in both storage modes: a dedicated column in SQLite, a private: frontmatter flag in the vault; metadata stays readable so a locked note shows as 🔒 without the key

Knowledge graph

  • Opens in its own tab: View → Graph View, toolbar button, or Ctrl+G / command palette
  • Global graph: all notes and resolved wiki-link edges; optional tag nodes, attachments, orphans and unresolved links
  • Local graph: the open note and its neighbours, 1 to 5 hops deep, with incoming, outgoing and neighbour links
  • Color groups: a query (text, path:, file: or tag:) with a colour; each note takes the first that matches
  • Forces, node sizes and drawing as in Obsidian: a note with many links stays bigger when zoomed out, hovering a note highlights only its links, and lines are a quiet grey
  • Native JavaFX Canvas force simulation (Barnes–Hut repulsion, link springs, alpha cooling — idle graph uses no CPU)
  • Zoom/pan, drag nodes, click a note node to open it; forces, filters, groups and local-graph options are remembered

Templates & daily note

  • Templates folder chosen in Preferences → Vault (subfolders included); Edit → Insert Template… writes a template at the cursor and merges its properties with the note's, as Obsidian does
  • Obsidian's variables: {{title}}, {{date}}, {{time}} and {{date:FORMAT}} with Obsidian's (moment) formats, in English and Spanish; plus Insert current date / time
  • Daily note (Ctrl/Cmd+Shift+D) with its own folder, name format (YYYY/MM/DD makes folders) and template; new notes can go to the folder in view, the vault root or a chosen folder
  • Templater syntax (optional): tp.date, tp.file, tp.frontmatter and tp.system with Templater's whitespace control, cursor placement and folder templates; anything that runs JavaScript is left as it is and reported
  • Settings live in the vault (.jylos/settings.json), so each vault keeps its own. Guide: Templates and Daily Note

Obsidian compatibility

  • Jylos and Obsidian can open the same vault: Jylos writes nothing of its own into notes (favourites and pinned notes live in .jylos/), keeps unchanged properties byte for byte and reads them as YAML 1.2, as Obsidian does
  • Tools → Clean Up Jylos Metadata… removes the fields older versions wrote, with a backup of each note
  • Tools → Import Obsidian Settings… takes the templates, daily-note, new-note location and Templater settings of the plugins Obsidian has on; Import Obsidian Bookmarks turns bookmarks into favourites. .obsidian is only read
  • Guide: Obsidian Compatibility

Vault, Git & attachments (filesystem mode)

  • Markdown vault with optional folder layout; non-.md files (PDF, images) open in built-in viewers
  • Git integration when the vault is a repository: status, stage/unstage, commit with message, and push/pull sync — all in the unified Git Sync panel (see Git menu)

Productivity

  • Links panel in the right info panel: linked mentions with the line of each link, unlinked mentions with a Link button, and outgoing links (a missing one creates the note)
  • Daily note and new note from template — see Templates & daily note
  • Per-note and bulk vault export to HTML/PDF
  • Import/export of individual notes
  • Import an Obsidian vault (folder hierarchy, frontmatter and tags preserved; .obsidian/ skipped) or an Evernote .enex export (ENML converted to Markdown, tags kept, attachments noted as placeholders) — File menu
  • Note version history (Tools → Note History, Ctrl/Cmd+Shift+H): local snapshots taken before each save (coalesced, capped at 50 per note), with a line diff viewer and one-click restore; private notes' snapshots stay encrypted

UI/UX

  • Light, dark, and system themes (OS theme polling when “System” is selected) + external CSS themes
  • CSS snippets: drop .css files into snippets/ and toggle them in Preferences to tweak the UI over the active theme (Obsidian-style)
  • External themes in themes/: Gruvbox, Gruvbox Material, Nord, Catppuccin (Mocha and Latte), Rosé Pine (and Dawn) and Retro Phosphor — download them from the themes page
  • Optional coloured icons by type, a colour per folder, and an icon size apart from the text size; everything grows with the interface font
  • Configurable sidebar/editor button presentation (text/icons/auto)
  • Centered sidebar navigation (folders, tags, recent, favorites, trash)
  • Layout menu in the toolbar: Explorer, classic columns or classic stacked; the choice is remembered
  • UI strings in English and Spanish (i18n/messages*.properties)
  • Toolbar uses Feather and Bootstrap icons via Ikonli (fth-* / bi-* in FXML — not separate image files)

Extensibility

  • External plugin JARs loaded from jylos/plugins/ (see scripts/build-plugins.sh; bytecode Java 21)
  • Plugin manager with core plugins (shipped and updated with Jylos, only switched on or off) and community plugins (in your plugins folder; restricted mode until you allow them), stable command IDs and a safe load/disable lifecycle
  • Plugin API: command palette, menus, side panels, preview enhancers, toolbar buttons and editor hooks (onBeforeTextInsert / onBeforeSave / onAfterSave) — see docs/PLUGINS.md
  • Built-in Mermaid diagram support in preview (plugin source under plugins-source/)
  • Theme catalog with external theme discovery and safe fallback

Screenshots

Explorer layout and Live Preview, with the links panel

Explorer layout and Live Preview, with the links panel

Source and linked reading view side by side

Source and linked reading view side by side

Mermaid diagrams in the reading view

Mermaid diagrams in the reading view

Global graph of a large vault, coloured by group

Global graph of a large vault, coloured by group

Graph settings: filters, local graph and colour groups

Graph settings: filters, local graph and colour groups

Local graph around a note

Local graph around a note

Kanban board inside a note

Kanban board inside a note

Obsidian-compatible Canvas

Obsidian-compatible Canvas

Dataview queries over note properties

Dataview queries over note properties

Plugin manager: core and community plugins

Plugin manager: core and community plugins

Preferences → Vault: templates, daily note and Templater

Preferences → Vault: templates, daily note and Templater

Command palette

Command palette

Classic layout: folders, notes and editor in columns

Classic layout: folders, notes and editor in columns

External theme: Gruvbox Material

External theme: Gruvbox Material

Light theme

Light theme

Technology Stack

  • Java 21
  • JavaFX 23
  • Maven 3.9+
  • SQLite JDBC
  • CodeMirror 6 embedded in JavaFX WebView (offline Markdown source and Live Preview editor)
  • JavaFX WebView + CommonMark (rendered Markdown preview; highlight.js and KaTeX assets are bundled offline)
  • Ikonli (Feather icons + Bootstrap Icons)
  • PDFBox + OpenHTMLToPDF (PDF export / viewer)
  • JUnit 5 + H2 (tests)

Prerequisites

  1. Java JDK 21
  2. Maven 3.9+

Check installation:

java -version
mvn -version

Quick Start

1) Clone

git clone https://github.com/RGiskard7/jylos.git
cd jylos

2) Build

From the repository root (produces jylos/target/jylos-<version>-uber.jar):

./scripts/build_all.sh
.\scripts\build_all.ps1

Equivalent Maven command:

mvn -f jylos/pom.xml clean package -DskipTests

3) Run

Option A — JBang (no build required):

jbang jylos@RGiskard7/jylos

Option B — Launcher script (sets JavaFX --module-path; requires the uber-JAR from step 2):

./scripts/launch-jylos.sh
.\scripts\launch-jylos.bat
# or
.\scripts\launch-jylos.ps1

run_all.* is an alternative dev runner. Plain java -jar without module-path often fails on JavaFX.

Scripts and Commands (All OS)

All commands assume the repository root (the folder that contains jylos/ and scripts/).

Build / Run Matrix

Purpose Linux/macOS Windows PowerShell Windows CMD
Build app ./scripts/build_all.sh .\scripts\build_all.ps1 N/A
Run app (dev runner) ./scripts/run_all.sh .\scripts\run_all.ps1 N/A
Run app (launcher, recommended) ./scripts/launch-jylos.sh .\scripts\launch-jylos.ps1 .\scripts\launch-jylos.bat

Tests and Quality Gates

Testing policy and test types are documented in docs/TESTING.md.

mvn -f jylos/pom.xml test
mvn -f jylos/pom.xml clean test
./scripts/smoke-phase-gate.sh
./scripts/hardening-storage-matrix.sh
.\scripts\smoke-phase-gate.ps1
.\scripts\hardening-storage-matrix.ps1

Javadoc

Generate API documentation with Maven:

mvn -f jylos/pom.xml javadoc:javadoc

The generated site is written under jylos/target/reports/apidocs/ and is intentionally ignored by Git.

Plugins (external JARs)

./scripts/build-plugins.sh
./scripts/build-plugins.sh --clean
.\scripts\build-plugins.ps1
.\scripts\build-plugins.ps1 -Clean

Themes (external)

./scripts/build-themes.sh
./scripts/build-themes.sh --clean
./scripts/build-themes.sh --appdata
.\scripts\build-themes.ps1
.\scripts\build-themes.ps1 -Clean
.\scripts\build-themes.ps1 -AppData

Packaging (native installers)

Requirements: full JDK 21+ (not JRE) with jpackage on PATH. Run from the repository root.

Each package-* script builds the uber-JAR, optionally runs build-plugins.sh, then invokes jpackage. Main class: com.example.jylos.Launcher.

Platform Command Typical output
macOS (DMG) ./scripts/package-macos.sh jylos/target/installers/Jylos-<version>.dmg
Linux (deb/rpm) ./scripts/package-linux.sh jylos/target/installers/
Arch Linux (pacman) ./scripts/package-linux-arch.sh (on Arch, as a regular user) jylos/target/installers/jylos-linux-amd64.pkg.tar.zst
Windows portable (app-image) .\scripts\package-windows.ps1 jylos\target\installers\Jylos\
Windows .exe installer (WiX) .\scripts\package-windows-exe.ps1 jylos\target\installers\Jylos-<version>.exe
Windows .msi installer (WiX) .\scripts\package-windows-msi.ps1 jylos\target\installers\Jylos-<version>.msi
./scripts/package-macos.sh
./scripts/package-linux.sh
.\scripts\package-windows.ps1

Icons: window + About dialog use jylos/src/main/resources/icons/app-icon.png; installers use icon.{icns,ico,png} (see app.properties and jylos/src/main/resources/icons/README.md). Details: docs/PACKAGING.md.

Maven development run

Prefer launchers for JavaFX. If using Maven directly:

mvn -f jylos/pom.xml javafx:run

Or:

mvn -f jylos/pom.xml clean compile exec:java -Dexec.mainClass="com.example.jylos.Launcher"

Project Structure

Repository root (contains the Maven module jylos/ and scripts/):

<repo-root>/
├── jylos/                              # Maven module (app)
│   ├── pom.xml
│   ├── src/main/java/com/example/jylos/
│   │   ├── config/                     # LoggerConfig
│   │   ├── data/                       # models; DAOs (sqlite/, filesystem/)
│   │   ├── event/                      # EventBus + domain events
│   │   ├── exceptions/
│   │   ├── git/                        # GitService (vault repositories)
│   │   ├── graph/                      # GraphBuilder, GraphData, nodes/edges
│   │   ├── insights/                   # knowledge-health analysis and reports
│   │   ├── plugin/                     # loader, manager, registries; mermaid/
│   │   ├── search/                     # advanced search parser + service
│   │   ├── service/                    # Note, Folder, Tag, Backlink, backup, …
│   │   ├── ui/
│   │   │   ├── controller/             # Main, Editor, Sidebar, Graph, Toolbar, …
│   │   │   ├── components/             # CommandPalette, QuickSwitcher, Git/insights dialogs, canvas
│   │   │   ├── preferences/            # persisted UI preference state
│   │   │   ├── theme/                  # theme application, catalogs, snippets
│   │   │   └── graph/                  # GraphCanvas (force-directed renderer)
│   │   ├── util/                       # WikiLinkResolver, MarkdownPreview, NoteExporter
│   │   └── workspace/                  # saved tab/layout workspaces
│   ├── src/main/resources/
│   │   ├── app.properties              # app name, icon paths, window title
│   │   ├── icons/                      # app-icon.png + icon.{ico,icns,png}
│   │   └── com/example/jylos/
│   │       ├── i18n/                   # messages.properties, messages_en/es
│   │       ├── ui/css/                 # modern-theme.css, dark-theme.css
│   │       ├── ui/view/                # FXML (MainView, EditorView, GraphView, …)
│   │       └── ui/preview/             # KaTeX, highlight.js (bundled offline)
│   ├── src/test/java/com/example/jylos/
│   ├── plugins/                        # runtime plugin JARs (often gitignored)
│   ├── themes/                         # installed external themes
│   ├── snippets/                       # user CSS snippets layered over the theme
│   ├── data/                           # runtime DB or vault (gitignored)
│   ├── logs/
│   └── backups/
├── plugins-source/                     # plugin sources → build-plugins → jylos/plugins/
├── themes/                             # theme sources → build-themes → jylos/themes/
├── resources/images/                   # README banner and screenshots
├── scripts/                            # build, launch, package, smoke tests
├── docs/                                # technical docs (see docs/README.md)
├── AGENTS.md
├── changelog.md
├── README.md
└── README.es.md

Configuration

Storage

  • SQLite (default): jylos/data/database.db
  • Filesystem vault: folder of .md notes with YAML frontmatter; switch in Tools → Switch storage. Changing from one filesystem vault to another reloads the session without restarting; switching between SQLite and filesystem still requires restart
  • Other runtime dirs (auto-created under jylos/): logs/, backups/, plugins/, themes/, snippets/

App icons

Asset Path Used for
In-app window + About jylos/src/main/resources/icons/app-icon.png app.icon.window in app.properties
Windows installer icons/icon.ico app.icon.windows
macOS installer icons/icon.icns app.icon.macos
Linux installer icons/icon.png app.icon.linux

Toolbar/sidebar icons are Feather and Bootstrap Icons glyphs via Ikonli (fth-* / bi-* in FXML), not files in icons/.

Themes

Source packs live in themes/<id>/ (theme.properties + theme.css). Development: ./scripts/build-themes.sh (copies to jylos/themes/). Packaged app: Preferences → Appearance → Open themes folder, copy the theme folder there and press Reload themes; the folder is ~/Library/Application Support/Jylos/themes/<id>/ (macOS), %APPDATA%\Jylos\themes\<id>\ (Windows), or ~/.local/share/jylos/themes/<id>/ (Linux). See themes/README.md.

CSS snippets

Drop plain .css files into the snippets/ folder to tweak the interface on top of the active theme (Obsidian-style), without authoring a full theme. Enable them in Preferences → CSS snippets; each enabled snippet is layered after the theme, so its rules win. Use Open folder in that dialog to reach the directory (<appData>/snippets). Snippet names must be simple .css filenames. Ready-made, theme-adaptive examples (Atom One, Nord, Solarized — each with a dark and light variant) live in snippets-examples/. Snippets can branch on the theme-dark / theme-light class Jylos sets on the scene root (Obsidian-style), and the same layered styles are propagated to themed dialogs and command overlays such as the command palette and quick switcher.

Plugins

  • Core plugins (Jylos's own) come with the installation and are updated with it; turn them on or off in Tools → Manage plugins.
  • Community plugins go in your plugins folder; allow them in the plugin manager (restricted mode is on in a new install), then install, reload or remove them there.
  • Build the core plugins: ./scripts/build-plugins.sh → jylos/plugins/*.jar (compile target Java 21). See docs/PLUGINS.md.

Documentation

Troubleshooting

JavaFX runtime errors

Use launch-jylos.* (module-path included). Run build_all first if the JAR is missing.

JAR not found

./scripts/build_all.sh

Maven/Java Missing

Ensure both are available in PATH:

java -version
mvn -version

JavaFX Parent-POM Warnings

Warnings such as Failed to build parent project for org.openjfx:javafx-* are known and non-blocking.

Contributing

  • Keep changes focused and incremental.
  • Run tests before opening PR.
  • Preserve SQLite/FileSystem and plugin compatibility.
  • Update documentation when behavior changes.
  • By submitting a contribution, you agree it is licensed under this project's MIT License (the same terms as the rest of the codebase), unless otherwise agreed in writing.

Changelog convention

  • Keep ## [Unreleased] at the top without a date; use it only for changes not assigned to a release yet.
  • When preparing a release, run scripts/prepare-release.sh x.y.z instead of editing by hand: it moves the [Unreleased] bullets into ## [x.y.z] - YYYY-MM-DD (today's date by default) and sets the same version in jylos/pom.xml. Commit that, merge to main, then push the tag vx.y.z; the release workflow refuses a tag that does not match. Full steps: docs/CICD.md.
  • One release section may include work done across multiple days. Do not create duplicate sections for the same version.
  • Write bullets from the user's point of view: fixes, behavior changes, compatibility notes, migration notes and documentation updates.
  • If a PR fixes a GitHub issue, put Fixes #123 in the PR description so GitHub closes it when the PR is merged.

License and trademarks

MIT License — Copyright © 2025–2026 Eduardo Díaz Sánchez.

You may use, modify, and distribute this software under the MIT terms; keep the copyright and license notice in copies or substantial portions. Contact: ed.dzsn@protonmail.com

Jylos bundles third-party libraries, fonts and emoji images under their own licenses (MIT, BSD, Apache-2.0, LGPL-2.1, CC-BY 4.0, SIL OFL 1.1 and others): see THIRD-PARTY-NOTICES.md.

The Jylos name, logo, icons, and branding are not covered by the MIT License — see TRADEMARKS.md.

About

Local-first knowledge management app with Markdown notes, wiki-links, backlinks, Canvas, Kanban, interactive graphs, plugins, themes, and SQLite or Markdown vault storage.

Topics

Resources

Stars

34 stars

Watchers

1 watching

Forks

Releases

Packages

Contributors

Languages