jsonsui turns a JSON Schema into a graphical configuration editor. The schema describes your configuration, jsonsui provides the interface: appropriate controls, descriptions, defaults, constraints and live validation. No more guessing which keys exist or which values are allowed.
- Open a JSON configuration. If it contains a
$schemareference, the schema is loaded automatically, otherwise you can load one manually. - Edit the values through checkboxes, drop-downs, numeric controls, nested objects and array cards.
- Review and save. Check your changes in the diff view before they are written to disk.
Built with Avalonia UI for Windows and Linux, with additional macOS builds available for community testing and a shared UI-independent core designed to support future frontends.
Why jsonsui? • Visual Editing • Downloads • Getting Started • Keyboard Shortcuts • CLI • Architecture
JSON is everywhere — especially in configuration files.
But as configurations grow, editing raw JSON becomes increasingly difficult:
- Where is the setting I need?
- What value is actually allowed here?
- Which fields are required?
- What does this property mean?
- How do I safely edit deeply nested objects and arrays?
jsonsui takes a different approach.
Instead of navigating large configuration files as raw text, you can explore their structure visually and edit the relevant parts through an intuitive UI.
Use a structured tree to move through objects and arrays without turning every individual JSON property into a tree node.
Properties are presented as appropriate UI controls instead of requiring manual JSON syntax.
When a JSON Schema is available, jsonsui uses it to understand the configuration and provide appropriate controls, descriptions, defaults, constraints, enums and validation.
The schema can also help you discover available properties. With Add Property, supported properties can be selected instead of having to remember or manually enter every possible configuration option.
Nested objects can be opened where they are needed, while arrays are presented as editable cards rather than a long list of indexed tree nodes.
The main experience in jsonsui is visual editing of JSON configurations.
Depending on the schema and value type, jsonsui can present properties as:
- Text fields
- Checkboxes
- Numeric controls
- Enum drop-downs
- Nullable value controls
- Array editors
- Nested object editors
Schema information can also provide:
- Descriptions and help text
- Default values
- Required fields
- Minimum / maximum constraints
- String length constraints
- Patterns
- Read-only properties
- Deprecated properties
The goal is simple:
Work with the configuration — not with its syntax.
JSON Schema is a central part of jsonsui.
If a JSON document contains a $schema reference, jsonsui can automatically detect and load the associated schema.
Schemas can also be loaded manually when needed.
For example, a schema can turn a configuration such as:
{
"port": 8080,
"tls": true,
"mode": "production"
}into an editor with appropriate controls and constraints instead of requiring the user to edit the raw JSON directly.
This allows the same JSON structure to become a guided configuration experience.
Complex configurations should not require endlessly scrolling through raw JSON.
jsonsui keeps the main navigation focused on meaningful structural elements and lets you drill into nested objects when needed.
Arrays are handled through an editor view with individual cards for their elements, making larger collections easier to understand and edit.
Before saving changes, jsonsui can compare the current configuration with the previous state and show structural changes.
The diff currently identifies:
- Added values
- Removed values
- Modified values
- Unchanged values
- Type changes
- Object and array changes
The result is presented in a dedicated diff view so changes can be reviewed before committing them to disk.
Visual editing is the primary experience, but jsonsui also provides a text-based JSON editor for situations where direct JSON editing is more appropriate.
This gives you a choice between:
Visual editing when structure and schema guidance matter.
Raw JSON when direct text editing is faster.
jsonsui also includes:
- ↩️ Undo / Redo
- 💾 Load and Save
- ✅ Live validation of supported schema constraints
- ➕ Add properties
- 🗑️ Remove properties
- 🌍 Localization
- 🔎 Tree filtering
- 🌓 Avalonia-based desktop UI
- 🖥️ Windows and Linux support
- ⌨️ Command-line entry points
The feature set is focused on making configuration editing safer and easier without hiding the underlying JSON.
| Shortcut | Action |
|---|---|
Ctrl+O |
Open file |
Ctrl+S |
Save |
Ctrl+Z |
Undo |
Ctrl+Y / Ctrl+Shift+Z |
Redo |
Ctrl+D |
Show diff |
Ctrl+Shift+L |
Focus the tree filter |
Navigation and editing (context-sensitive)
| Key | Action |
|---|---|
↑ / ↓ |
Move selection |
Home / End |
First / last item |
← / → |
Collapse / expand a tree node |
Enter |
Activate node, open card or commit an edit |
Space |
Expand/collapse or select a tree node |
Insert |
Add an array item |
Delete |
Delete property or array card |
F2 |
Rename a property |
Shift+F10 / menu key |
Open property actions |
Esc |
Close diff, leave a nested context, or return to the tree |
Alt+← |
Go up one nested level (same as the back button) |
Backspace |
Go up one nested level (outside text inputs) |
jsonsui is developed with AI-assisted development tools.
Rather than generating the project in one large step, development is done iteratively in small, verifiable stages.
The workflow typically looks like this:
Idea / Requirement
↓
Architecture & UX decision
↓
Small implementation step
↓
Build & verification
↓
Manual UI testing
↓
Regression check
↓
Next iteration
AI is used as a development tool for tasks such as implementation, refactoring, investigation and debugging.
Architecture, requirements, design decisions, verification and final acceptance remain human-driven.
This approach allows jsonsui to be developed quickly while keeping the codebase understandable and intentionally designed.
jsonsui is built around a UI-independent core:
┌──────────────────────┐
│ Jsonsui.UI │
│ Avalonia UI │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Jsonsui.Core │
│ │
│ JSON editing logic │
│ Schema handling │
│ Validation │
│ Navigation │
│ Undo / Redo │
│ Diff │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ Jsonsui.Tui │
│ CLI / console │
└──────────────────────┘
The separation keeps the core JSON and schema logic independent from Avalonia and leaves room for additional frontends in the future.
Pre-built releases are available on the Releases page.
Two variants are provided for every platform:
| Variant | Requires | Size | Contents |
|---|---|---|---|
*-full.* |
nothing | large | single executable |
*-slim.* |
.NET 10 Runtime | small | single executable |
| Platform | Full (self-contained) | Slim (framework-dependent) |
|---|---|---|
| Windows x64 | jsonsui-win-x64-full.zip |
jsonsui-win-x64-slim.zip |
| Linux x64 | jsonsui-linux-x64-full.tar.gz |
jsonsui-linux-x64-slim.tar.gz |
| macOS x64 | jsonsui-macos-x64-full.zip |
jsonsui-macos-x64-slim.zip |
| macOS arm64 | jsonsui-macos-arm64-full.zip |
jsonsui-macos-arm64-slim.zip |
Each archive contains a jsonsui/ folder with the executable (jsonsui.exe on Windows, jsonsui on Linux and macOS).
macOS binaries are ad-hoc signed. On first launch you may need to allow the app in System Settings → Privacy & Security.
On Windows, if SmartScreen warns about the app, the user only needs to right‑click the EXE, open Properties, and check Unblock under Security. After that, the app runs normally without further warnings.
- .NET 10 SDK
dotnet build Jsonsui.slnxdotnet test Jsonsui.slnxdotnet run --project src/Jsonsui.UIYou can also provide a JSON configuration and, if required, a schema through the command line.
The project also includes a lightweight command-line entry point.
Example:
dotnet run --project src/Jsonsui.Tui -- ./config.jsonAvailable functionality includes:
- JSON input
- Schema input
- JSON diff
- Language selection
- Help
The console project currently provides command-line functionality rather than a full interactive terminal editor.
jsonsui is already usable for schema-driven configuration, but there is plenty of room to expand it.
Possible future directions include:
- More advanced JSON Schema support
- Improved schema composition (
oneOf,anyOf,allOf) - Further diff capabilities
- Additional frontends
- Web-based configuration editing
- A fully interactive terminal UI
- Additional integrations
The roadmap is intentionally open — the project will evolve based on practical use and feedback.
jsonsui is open source and developed independently.
If you find it useful, there are several ways to support the project:
- ⭐ Star the repository
- 🐛 Report bugs
- 💡 Suggest improvements
- 🔧 Contribute code
- 📣 Share the project
- ❤️ Support future development
Financial support can help make it possible to spend more time on jsonsui and future features.
jsonsui itself is licensed under the MIT License. It uses third-party libraries, fonts and icons that are provided under their own permissive licenses (MIT, BSD-3-Clause, ISC and SIL OFL 1.1).
THIRD-PARTY-NOTICES.txt— full list of bundled components and their license texts.LICENSES/— license texts for the bundled fonts and icons.
jsonsui is released under the MIT License.
See LICENSE for details.