Projects sharing features with Json Editor

form-create is a JSON-driven form generator and low-code form builder that renders dynamic web forms and validation logic from configuration files. It functions as a data-driven form orchestrator for managing field dependencies and hierarchical data structures within complex layouts. The system includes a visual drag-and-drop interface for designing data entry layouts and automatically generating their corresponding configuration structures. It provides a dynamic UI component library of adaptable form fields and layout containers designed for cross-framework integration and mobile responsiven

This project is a JSON-based form rendering framework and visual creator designed for dynamic data collection. It provides a JavaScript form builder library that transforms JSON schemas into functional web forms and multi-step wizards, with a dedicated visual survey creator for designing layouts and branching logic without writing code. The library is distinguished by its bidirectional PDF integration, which allows the conversion of JSON schemas into fillable PDF documents and the extraction of structured data from existing PDFs. It also features advanced capabilities for creating scored asse

form-render is a schema-driven UI framework that translates structured JSON definitions into functional administrative layouts, interactive web forms, and data visualizations. It serves as a system for rendering components and validation logic based on declarative schemas rather than manual imperative code. The framework includes a JSON-based form generator and a data table component that transforms structured data into searchable and sortable interfaces. It also features a visualization engine that renders data charts from simplified configuration schemas and a visual editor for designing fo

Formtastic is a Ruby on Rails form builder that provides a domain-specific language for generating semantically rich and accessible HTML forms. It functions as a model-driven framework that automatically maps database schema attributes and associations to corresponding input fields, streamlining the creation of data entry interfaces. The framework distinguishes itself through a hierarchical lookup system that manages internationalized labels, hints, and action buttons across different model and attribute namespaces. It also supports complex data relationships by recursively processing nested

Leva is a React GUI control panel and real-time parameter editor used to monitor and tweak application state and variables without modifying code or reloading the page. It functions as a dynamic state debugger and extensible input library that provides a visual interface for fine-tuning numerical, boolean, and text values within a running web application. The project distinguishes itself through a plugin system that allows the creation of custom input components and specialized behaviors to support unique data types. It utilizes type-inference to automatically map data to the appropriate visu

Field-form is a library for managing complex form state, validation, and field synchronization within React component trees. It functions as a state management solution that uses a shared provider to distribute form data and validation messages across nested components. The library distinguishes itself through a dynamic field registry that supports the addition, removal, and reordering of form controls. It employs a field-level subscription model to ensure that individual components only re-render when their specific state slices change, and it provides an imperative interface for triggering

Unform is a React form state manager designed to handle the state, validation, and submission of complex user input forms. It utilizes an uncontrolled form API that minimizes re-renders by using references instead of synchronized state to manage form data. The library features a nested data mapper that organizes fields into hierarchical objects and arrays using scoping and dot notation. It also includes a custom input adapter to connect third-party UI components and non-standard inputs to the centralized form state, and a validation engine that checks submitted data against defined schemas to

This library provides a dynamic engine for Vue that automatically renders interactive web forms from JSON Schema definitions. It functions as a data-driven framework that maps schema constraints to UI components, managing state synchronization and input validation throughout the form lifecycle. The project distinguishes itself through a flexible adapter system that bridges structured data with established design systems, such as Element UI, Ant Design, or Naive UI. It supports complex interface requirements by allowing developers to inject custom logic, event listeners, and specialized templa

Admin-bro is a Node.js administrative panel framework that automatically transforms database schemas into functional content management systems and backend dashboards. It provides a visual interface for performing create, read, update, and delete operations on records across various supported data sources. The framework uses model-driven UI generation to map database metadata to form components and employs an adapter-based abstraction layer to translate administrative operations into specific database queries. It supports the execution of custom business logic and operational workflows throug

This project is a declarative state manager and component library for building complex, interactive forms in React applications. It provides a framework for constructing form interfaces by mapping structured data schemas to modular UI components, ensuring that input state and data integrity are handled consistently across an application. The library distinguishes itself through a schema-driven approach that decouples form structure from rendering logic. By utilizing centralized validation middleware and configuration-based styling, it allows developers to enforce business rules and maintain v

This project is a schema-based form generator for Vue.js that constructs interactive user interfaces by parsing structured data configurations. It automates the creation of form layouts, data binding, and field rendering, eliminating the need for manual template creation for individual forms. The system distinguishes itself through a registry-based architecture that allows for the integration of custom input components. By mapping specialized field types to the generation engine, developers can extend the library to handle unique data types or complex interface requirements that fall outside

This project is a Python implementation of the JSON Schema specification, providing a library for verifying that data instances conform to defined schemas. It serves as a data validation framework capable of validating both the data itself and the schemas against official meta-schemas to ensure structural correctness. The library features a schema reference resolver that maps URIs to definitions, enabling the resolution of internal and remote references for modular schema management. It is designed for extensibility, allowing for the definition of custom keywords, custom type-checking logic,

Bubble-Card is a customizable UI framework and custom card for Home Assistant dashboards. It provides a system for building interactive smart home interfaces using JavaScript templates and CSS variables to create state-aware components. The project is distinguished by its use of JavaScript dashboard templating to dynamically update icons, colors, and text in real-time based on entity states. It includes a modular CSS style manager for creating and sharing reusable style modules and functional logic to maintain visual consistency across multiple cards. The framework covers smart home device c

React-admin is a framework for building data-driven administrative interfaces that connect to REST or GraphQL backends. It provides a comprehensive suite of tools for managing the full lifecycle of administrative applications, including resource-oriented routing, declarative form scaffolding, and context-driven state management. By utilizing a modular adapter-based architecture, the framework abstracts backend communication, allowing developers to build consistent CRUD interfaces that handle data fetching, authentication, and synchronization automatically. The project distinguishes itself thr

Revel is a full-stack web framework and toolkit for building applications with the Go language. It implements a model-view-controller architecture to separate business logic from user interface rendering, providing a comprehensive system for routing, parameter binding, and session management. The project distinguishes itself with a high-productivity development environment featuring automatic code compilation and hot-reloading, which refreshes the application state and templates upon file changes without requiring manual restarts. It also employs reflection-based parameter binding to automati

Wagtail is an open-source content management system built on the Django web framework. It provides a structured, tree-based approach to content modeling, allowing developers to define custom page types and reusable content components that are managed through a highly customizable administrative interface. The platform distinguishes itself through its flexible, block-based content composition system, which enables editors to assemble complex page layouts dynamically. It also offers robust support for multi-site and multi-lingual environments, allowing organizations to manage distinct websites

Vapor is a comprehensive server-side web framework designed for building scalable, high-performance applications and APIs in Swift. It provides a non-blocking, event-loop-based runtime that manages concurrent task processing, background job queues, and asynchronous request handling. The framework is built around a dependency injection container that manages the lifecycle and resolution of services, configurations, and database connections throughout the request pipeline. The framework distinguishes itself through a protocol-oriented design that emphasizes type safety across all layers of the

FastUI is a server-driven UI system and Pydantic UI framework that transforms backend data models into functional web interfaces. It operates as a model-based frontend generator where the server controls the layout and behavior of the user interface through structured data schemas, enabling a low-code approach to web development. The project allows for the definition of visual hierarchies and component properties on the backend, using a JSON-based protocol to communicate UI structure between the server and client. It utilizes schema-driven generation to automate the creation of interfaces, in

Keystone Classic is a Node.js headless content management system and web application framework. It provides a database schema framework for defining structured data models and validation rules to organize information. The system automatically generates a responsive administrative dashboard based on predefined data models and database fields, allowing for content management and record editing without custom administration code. The framework covers identity and security through session state management and password encryption. It includes capabilities for request routing, form submission proc

Hypothesis is a Python property-based testing library and data generation engine. It enables the discovery of edge cases and bugs by generating a wide range of randomized inputs based on defined strategies and shrinking complex failing examples to their smallest possible form. It also functions as a state machine testing framework to verify system behavior across sequences of interdependent operations. The project features a fuzzing integration layer that converts raw byte buffers from coverage-guided fuzzers into structured test cases. It includes a persistence mechanism to store and synchro

This project is a web-based documentation viewer and interactive console designed to render API specifications into browser-based interfaces. It provides a framework for exploring endpoints, managing authorization flows, and executing live test requests directly against defined services. By parsing specification files into structured data models, the tool generates dynamic interfaces that allow developers to interact with API definitions in real time. The console is built as a library of reusable web components, enabling developers to embed documentation viewers into existing web applications

This project is a JSON schema form builder and dynamic form generator. It functions as an API-driven data collector that creates customizable input fields and layouts based on JSON schema definitions. The system serves as a schema-based input validator, enforcing data integrity through predefined schemas and providing real-time feedback to users. It allows for the creation of web forms where input types, labels, and placeholders can be modified without changing the source code. The tool manages the end-to-end workflow of interactive user input, covering dynamic form generation, client-side d

This project is a JSON Schema form generator and React UI component that automatically creates web forms based on JSON Schema definitions. It serves as a schema-driven form builder used to transform declarative data definitions into interactive user interfaces for data entry and validation. The tool provides capabilities for dynamic form generation and JSON Schema integration, allowing for the automatic creation of input fields and layouts to avoid manual coding. It implements schema-based validation to ensure user input adheres to standardized JSON Schema rules in real time. The system mana

This project is a framework for generating synthetic tabular data that preserves the statistical properties and relational integrity of original source datasets. It functions as a metadata-driven engine, utilizing language models to synthesize information even when original training samples are restricted. The system is designed to maintain logical consistency across complex, multi-table structures while ensuring that generated outputs adhere to defined schema requirements. The platform distinguishes itself through a focus on privacy-preserving synthesis, integrating tools to quantify and mit

Cyclops is a Helm template orchestrator and management interface used to configure and deploy containerized applications to Kubernetes clusters. It serves as a deployment tool that abstracts complex infrastructure configurations into simplified inputs, allowing users to manage applications through a dedicated user interface. The project differentiates itself by using schema-driven form generation and metadata-driven UI rendering to create self-service deployment portals. These interfaces are generated by parsing template files and their associated schemas, mapping specific attributes to visua

The Frappe HR Management System is a human resources platform built on the Frappe framework for managing employee lifecycles, payroll, and attendance. The system provides tools for payroll and tax automation, including the generation of salary structures, tax slab calculations, and automated payslips. It includes an attendance and leave manager with geolocation-based check-ins and configurable holiday calendars, as well as a performance appraisal framework for goal alignment and structured review cycles. Additional capabilities cover the full employee lifecycle from onboarding to exit, along

ng-admin is an AngularJS framework for generating low-code administrative dashboards and graphical user interfaces for managing RESTful API data. It functions as a REST client GUI that translates HTTP requests and responses into editable forms and data tables. The framework utilizes a declarative configuration to map API endpoints to UI components and generates interface views based on provided schema objects. It allows for the customization of the API client through interceptors that transform incoming and outgoing data formats to match specific server requirements. The system provides stan