samuelmtimbo/unit
Unit
Unit is a visual programming system and graph-based integrated development environment used to build functional software by connecting state machines and primitive operations. It serves as a node-based logic editor and state machine orchestrator that transforms visual program specifications into standalone JavaScript files for deployment as static websites.
The system distinguishes itself through a visual compiler that can render program bundles into active websites and perform bi-directional graph inspection, allowing a live rendered application to be converted back into its original visual graph for debugging. It employs a spatial workspace where low-level system APIs are wrapped into reusable state machines to create a consistent library of functional units.
The platform covers a wide range of capabilities including graph-based logic composition with pin-based data routing, recursive subgraph nesting, and manual JSON data creation. It also provides tools for project serialization, hierarchy navigation between parent and child nodes, and a final rendering preview to view the output of a graph.
Features
- Visual-to-JavaScript Compilers - Transforms visual program specifications into standalone JavaScript files for deployment as static websites.
- Node-Based Logic Composition - Represents programs as a network of nodes and edges where data flows through connected input and output pins.
- Interactive Prototyping - Provides rapid iteration on application logic with a live editor that renders programs into functional websites.
- Visual Graph IDEs - Features a zoomable canvas, hierarchy navigation, and live preview for comprehensive node-based software design.
- Visual Data Flow Builders - Maps how data moves between inputs and outputs using a piping system of compatible functional pins.
- Static Visual Graph Compilers - Transforms functional unit graphs into static files that execute logic within a standard web browser environment.
- Visual Logic Programming - Converts program specifications into active systems and visual components using a visual logic programming paradigm.
- State-Machine API Wrappers - Turns system and environment APIs into a standardized library of reusable visual state machines.
- System API Wrappers - Wraps low-level system and environment APIs into reusable state machines to create a standard library of operations.
- Function Piping - Implements a visual piping system that passes values through a sequence of multi-input and multi-output units.
- Architectural State Machines - Encapsulates low-level system APIs into discrete state machines to manage transitions and application architecture.
- State Machine Orchestrators - Orchestrates application logic by wrapping low-level APIs into reusable state machines.
- Node-Based Logic Interfaces - Designs complex program flows using a visual canvas of connected units and reusable subgraphs.
- Pin-Based Connectivity Models - Manages information flow by matching compatible output and input pins to define the execution order of operations.
- Visual Programming Environments - Provides a canvas-based interface for constructing and configuring modular software components via a graph.
- Bi-Directional Graph Inspection - Enables the conversion of a live rendered application back into its original visual graph for debugging and modification.
- Visual Programming Environments - Allows live programming via a visual environment where graphs are manipulated using gestures and shortcuts.
- Subgraph Grouping - Supports grouping multiple nodes into single reusable units or expanding them back into components.
- Recursive Hierarchies - Allows grouping multiple units into a single parent node to create hierarchical levels of abstraction within the graph.
- Subgraph Cloning - Supports creating shallow or deep copies of units and subgraphs to reuse existing logic and state.
- Hierarchical Graph Navigation - Allows users to navigate between parent graphs and child units to modify internal logic and organization.
- Standard Logical Unit Libraries - Offers a standard collection of predefined logical unit graphs to simplify program composition and ensure portability.
- Live Graph Reverse-Inspection - Encapsulates a live unit website back into a graph editor to debug its underlying structure.
- Application Output Previews - Hides the editing interface to view the final visual output of the graph as a rendered website.
- Standalone Bundling - Compiles program bundles into static JavaScript files that load into standard HTML pages as standalone websites.
- Schema-Driven Bundling - Serializes visual graph specifications into portable bundles that can be compiled into standalone JavaScript applications.
Star history
How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.
