How jline/jline3 works
Project type and purpose
• JLine is an open-source, multi-module Java console library.
• Purpose: provide a portable, flexible console/terminal abstraction with line-editing, history, completion, syntax highlighting, styling, UI widgets, built-in commands, and remote shells (SSH/Telnet).
High-level module structure
• Core/low-level modules:
• jline-terminal: Terminal SPI, providers (Posix, Windows, exec).
• jansi-core, terminal-jansi, terminal-jna, terminal-jni, terminal-ffm, native: platform-specific native/Java bridges for PTYs, ANSI support.
• curses: high-level GUI abstraction on top of terminal.
• Mid-level modules:
• jline-reader: line-editor, parser, completers, history.
• High-level modules:
• jline-console: REPL engine, command registry, scripting support.
• jline-console-ui: interactive prompts, menus, checkboxes, lists.
• jline-builtins: built-in shell commands (nano, less, tmux, etc.) and configuration.
• jline-remote-ssh, jline-remote-telnet: SSH/Telnet server front-ends built on console and reader.
• Supporting modules:
• groovy: Groovy scripting integration.
• demo, graal: sample applications, Graal native-image demos.
• website: documentation site (Docusaurus).
Dependency relationships and data flow
• Application → uses JLine API.
• jline-terminal sits at the bottom (SPI for I/O).
• TerminalProviders (exec, native, jansi, jna, jni, ffm) loaded via Java ServiceLoader.
• jline-reader depends on jline-terminal (for raw input/output).
• jline-console depends on jline-reader + jline-terminal.
• jline-console-ui depends on jline-console + jline-style.
• jline-builtins depends on jline-console-ui + jline-reader.
• jline-remote-ssh/telnet depend on jline-console + jline-builtins (for shell commands).
• curses and groovy integrate at various levels (curses on terminal + UI; groovy as script engine in console).
Architectural patterns and principles
• Layered modular architecture: core → reader → console → UI/commands → remote.
• SPI/ServiceLoader for pluggable TerminalProviders.
• Builder patterns (TerminalBuilder, LineReaderBuilder) for configuration.
• Separation of concerns: I/O abstraction, line editing, parsing, UI, commands.
• Extensibility points: custom Completers, Highlighters, Widgets, Style sources, Script engines.
Elements
• Clear labels on each module/component (use full artifactId).
• Rectangles for core libraries/modules
Quick sketch of component grouping
┌──────────────────────────────────┐
│ Application (user code) │
└─────────┬────────────────────────┘
│ uses public APIs
┌─────────▼─────────┐
│ jline-console-ui │
└─────────┬─────────┘
│ builds on
┌─────────▼─────────┐ plugins
│ jline-console │◀──────────────┐
└─────────┬─────────┘ │
│ uses reader │
┌─────────▼─────────┐ ┌─────────▼─────────┐
│ jline-reader │ │ groovy scripting │
└─────────┬─────────┘ └───────────────────┘
│ uses terminal
┌─────────▼─────────┐ SPI/providers
│ jline-terminal │◀────────────────────────┐
└───────────────────┘ │
│ │ ┌────────────────────┐ │
│ └─────▶│ jansi, jna, jni, │ │
│ │ ffm, native, exec │ │
│ └────────────────────┘ │
│ │
└─────────────▶ curses/UI widgets────┘