FormLogic

Build forms and business apps with a backend, a database and the AI you choose.

Create forms, dashboards, portals and automations in one workspace. Import an existing app, edit its interface and backend, and manage its SQLite records without leaving FormLogic. Build editable apps with Softn, host them on FormLogic, and connect OAIY for AI and local services. Add Aokie when calls, messages and appointments belong in the same app.

Try the live demo · Build your first app · Meet Aokie · Self-host FormLogic

_{Actual running interface, captured September 2026 with fictional studio data. See screenshot details.}

---

From a form to a connected app

Install an editable app. The 29 business packs now include 32 Softn workspaces, their linked forms, record stores, roles, reports and workflows. Download the complete source ZIP or customise an installed copy in App Studio. Operators can add or change pack folders without rebuilding the site. Packs can also carry native .logic routes and SQLite migrations. Pack folders and project format.

1. Start with your data. Create a form visually, use AI, or choose a marketplace starter.
2. Build the workspace. Add screens, dashboards, reports, branding, members and roles in App Studio.
3. Connect the work. Use flows and scripts to turn submissions and device events into the next action.
4. Make it your own. Import an editable .softn project, open the embedded Visual Builder or AI Studio, and host its private .logic backend and SQLite database.
5. Share the same records. Add forms to another app without copying the data, or move a complete integration after reviewing its permissions.

A workspace that fits the screen Forms, apps and automations stay within reach on desktop and mobile. See recent activity, open the relevant tool and move between your apps from the same dashboard. Forms: validation, conditional logic, linked records, uploads and custom screens. Apps: branded portals, shared data, role-aware navigation, charts and reports. Automation: visual flows, private backend actions, scoped APIs and connected devices. Explore a populated demo · How connected workspaces work

Your app, from interface to database

Bring an existing Softn project or start in FormLogic. Keep its interface, backend source, records and automations together, and download the editable project when you want to take it elsewhere.

Work on…	In FormLogic
Layout and components	Open Visual Builder from App Studio’s hosting tools.
Source and AI changes	Open AI Studio with your configured AI, review its changes, then publish the draft.
Screens and private backend	Edit highlighted .ui and .logic source with line numbers, search, wrapping and light/dark themes. Installed SQL migrations stay read-only.
SQLite records	Create records, view full values, edit fields and confirm deletions. Desktop tables become record cards on mobile.
Record automations	Connect a created, updated or deleted database event to a flow, including account-registration events.
Visitor access	Keep an app’s own sign-in or require FormLogic membership. Owner administration stays separate.

_{Current Backend editor. The fictional Service desk app uses private ZIPP logic and its own SQLite database.}

Manage the data where you build the app. List previews stay compact; editing loads full text. Database defaults, NULL values and constraints are respected, and stale changes are rejected.

Ready for a small screen. Open a record, change its fields and save from the same mobile workspace.

Owner record controls write directly to SQLite and queue connected automations. They enforce database constraints, but do not call the app’s backend validation functions. Use the app itself when those business rules are required. Existing records need a complete visible primary key for editing/deletion; secrets, generated fields and binary values are protected from ordinary field editing.

Editor changes return to a draft. Publishing preserves existing records; editor previews do not execute the hosted backend. A downloaded project includes source and media, without database records or server credentials. Custom domains also require DNS, web-server and HTTPS configuration.

Build and host an app · Manage database records · Screenshot notes

One connected platform

Layer	What it owns	What it unlocks
FormLogic	Forms, records, apps, access control, flows, hosting and APIs	A shared backend and operational workspace
Softn	Portable app projects, Visual Builder, AI Studio and runtime	Editable .softn projects and integrated app tools
OAIY (paired desktop, separate repository)	Local models, services, supervised plugins, hardware connectors and headless flow execution	Local capability with cloud visibility—even when the browser is closed
Aokie	Bluetooth phone control, live call audio, speech and durable call/SMS events	A phone receptionist whose conversations become structured business work

You can use the visual builders without connecting AI. Pair OAIY when you need local models, services, devices or background execution. FormLogic owns the app records and permissions; the connected runtime owns its local capabilities.

---

Add Aokie to your front desk

Calls, appointments, messages, transcripts, follow-ups and device logs in one app. The Aokie starter includes a portable front-desk interface, and the same forms can be shared with an existing FormLogic app. That app keeps its original home and gains a Front desk view.

Aokie runs as an OAIY plugin and connects to a compatible phone over Bluetooth. FormLogic stores the resulting records and runs the business workflows. Use Open call controls, Manage appointments and Manage messages to move from the overview to the relevant tools.

What happens on a call

1. A call rings on the paired mobile phone.
2. Aokie receives call control and audio over Bluetooth HFP/SCO.
3. Local speech recognition turns the caller's voice into text.
4. A local—or explicitly configured remote—language model chooses a reply and text-to-speech plays it back.
5. Durable events become FormLogic call records, transcript turns, caller details, summaries, appointment requests and follow-up work.
6. Flows can notify staff, look up a returning caller, update records, draft a response or route the next action.

Built for an actual front desk

• Custom receptionist with your business name, greeting, voice, model and instructions.
• Incoming and outgoing calls with answer, reject, hang up, outbound dialing and operator speech.
• Conversation history with caller and assistant turns, overlap labels and interrupted replies.
• Messages and follow-ups with incoming SMS, reviewed drafts and configured callback workflows.
• Waiting-call visibility with a read-only summary of waiting and held callers in OAIY.
• Natural interruption with optional barge-in and echo cancellation.
• Local-first voice loop using local speech recognition, a local LLM and local text-to-speech by default.
• Remote visibility through the FormLogic app while OAIY handles the local phone connection.
• Crash-safe delivery through a write-before-emit event outbox with acknowledgements, replay and idempotency.
• Privacy-aware operation with DPAPI-protected transcript/SMS outbox payloads and conversation content excluded from logs by default.
• Safer defaults: auto-answer is opt-in and defaults off.

Important

Aokie is a hardware beta for Windows 10/11 x64 and requires a supported USB Bluetooth dongle. It captures appointment requests for staff or a configured flow to confirm; it should not be treated as silently confirming bookings on its own. Local processing is the default path, but any remote AI or speech endpoint you configure receives the audio or text it needs.

Explore Aokie · Read the hardware guide · Open the Aokie repository

---

One backend, many portals

Forms are shared data models—not copies trapped inside separate apps. Attach the same forms to several experiences and give each one its own audience, branding and permissions.

A customer can submit and track their own request. A field worker can see the queue and update the job. An administrator can access every record, dashboard and report. All three views work over the same data.

• Each app keeps its own slug, branding, members, roles, navigation and dashboards.
• The form keeps its schema, validation, linked records, scripts, webhooks and responses.
• Server-side filtering removes forms, navigation, reports and widgets a member cannot see.
• Create companion app builds a second portal over the existing forms without cloning the records.

The complete model is documented in One backend, many portals.

Build it your way

Forms that grow into software

Build focused public forms or complete data models with short and long text, email, phone, number, date/time, choices, ratings, signatures, uploads, locations, calculated values, hidden values and linked records. Add validation, conditional logic, version history, webhooks and a server-side onSubmit script.

Form starters load from JSON folders at runtime. Add a custom file or override a bundled template without rebuilding the frontend; categories follow the available files. Extend the template library.

Dashboards without dashboard code

Compose KPI, bar, line, area, pie, donut, table, record-list and activity widgets in a drag-and-drop grid. Give the app home screen and each form section its own operational view, then turn the same data into printable PDF reports.

Client apps and private backend logic

• Softn clients combine .ui interfaces and .logic behavior in an editable app project.
• Native app hosting runs private .logic route handlers in ZIPP with declared SQLite migrations.
• Hosted backend actions provide an alternative named-action format with permission-checked, transactional SQLite record operations.
• Sandboxed app logic runs lifecycle hooks and returns permission-checked effects.
• Custom screens run as sandboxed HTML/CSS/JavaScript behind an iframe and postMessage SDK.
• FormLogic SDK provides permission-aware React hooks and components for first-party screens.
• Server scripts run in a budgeted ZIPP sandbox with guarded access to record and HTTP helpers.

Visual flows that do real work

React to form submissions, native database record changes, connector events and manual runs. Branch, transform and format data, call an OpenAI-compatible model, operate connectors, drive approved local services and read or write FormLogic records. Runs are tracked with correlation IDs, idempotency and history.

Bring your own AI

Open Connect your AI and follow Choose → Connect → Use in FormLogic.

• OAIY Desktop: connect Codex, a provider API or local models. Choose Through my FormLogic account and link this site in OAIY → Connections → Linked account to use it from another computer or phone. Direct browser pairing is also available on the same computer.
• Your own API provider: use the browser's provider editor, test the connection and choose a default. The provider must allow browser requests.
• External AI clients: use scoped OAuth/MCP access to create and edit apps, forms, screens, roles, flows and hosted projects.

_{Actual setup screen with a fictional account. No AI provider is connected in this demo.}

FormLogic defaults to free access and bring-your-own AI. Your provider may charge separately. Operator-funded Site AI is off by default; some specialised generation routes still require it. See AI setup and optional plans for the current scope.

Portable by design

• Export forms and responses as familiar files.
• Download an editable .softn client, or export a signed .formlogic package or JSON pack.
• Host custom apps with private backend actions and a separate app database.
• Downloaded clients contain interface code, not account credentials or an offline copy of the backend.
• Review capabilities and trust level before importing a package.
• Run in the hosted service, on your own infrastructure, as a PWA or through the native runtime.

Start from a working business app

FormLogic ships 29 marketplace packs backed by real forms, linked records, roles, dashboards, reports and populated demos. Several packs include more than one portal, producing 32 demo apps in the no-signup gallery.

Trades & field service	Hospitality & food	Health, beauty & fitness
Plumbing, workshop, handyman, cleaning and pet-care operations	Café, burger, restaurant, catering and short-stay operations	Salon, training/coaching and clinic front-desk operations

Retail & operations	Compliance & field ops	Business, finance & voice
Inventory, retail-store and fleet operations	OHS/quality, construction and agriculture	Billing, repairs, HR, service, events, finance and Aokie

View all 29 marketplace packs

App	Category	What it runs
Plumbing & Trades Field Service	Trades & Field Service	Customers → jobs → site visits → invoices → parts
Mechanic Workshop Manager	Trades & Field Service	Customers → vehicles → job cards → parts → invoices
Property Maintenance & Handyman	Trades & Field Service	Properties → tenants → requests → work orders → inspections
CleanShift — Cleaning Scheduler	Trades & Field Service	Clients → teams → jobs → quality checks → supplies → issues
PawRoute — Dog Walking & Pet Care	Trades & Field Service	Clients → pets → bookings → visits → incidents → care notes
BrewDesk — Cafe & Barista Ops	Hospitality & Food	Orders → barista queue → menu → stock → roster → daily close
GrillStack — Burger Command Center	Hospitality & Food	Orders → kitchen pass → prep → stock → shifts → close
PassMaster — Restaurant Service	Hospitality & Food	Reservations → tables → orders → kitchen tickets → shift close
CaterCraft — Catering & Events	Hospitality & Food	Clients → packages → events → production → deliveries
StayReady — Short-Stay Turnover	Hospitality & Food	Properties → bookings → turnovers → inspections → supplies
Hair Salon & Beauty Studio	Beauty, Health & Fitness	Clients → services → stylists → appointments → product sales
FitStudio — Training & Coaching	Beauty, Health & Fitness	Clients → trainers → sessions → assessments → payments
Clinic Appointment & Intake	Beauty, Health & Fitness	Patients → providers → requests → intake → follow-ups
Inventory & Purchase Orders	Retail & Operations	Products → suppliers → purchase orders → stock movements
CounterFlow — Retail Store Ops	Retail & Operations	Products → suppliers → stock → tasks → returns
FleetFlow — Fleet & Driver Log	Retail & Operations	Vehicles → drivers → trips → fuel → maintenance → incidents
OHS & Quality Management	Field Ops & Compliance	Incidents → hazards → audits → corrective actions → NCRs
SitePulse — Construction Site Diary	Field Ops & Compliance	Projects → diaries → deliveries → defects → variations
AgriLog — Farm Jobs & Harvest	Field Ops & Compliance	Paddocks → jobs → harvests → chemicals → machinery
VenueOps — Venue Hire & Bookings	Bookings & Education	Spaces → hirers → bookings → setups → payments → incidents
TutorTrack — Tutoring & Lessons	Bookings & Education	Students → tutors → lessons → progress → invoices
Event Management	Bookings & Education	Registration → speakers → vendors → volunteers → feedback
Job & Invoice Management	Billing & Business	Clients → jobs → quotes → invoices → payments
RepairBench — Device Repair Shop	Billing & Business	Customers → devices → repairs → parts → sign-off → pickup
HR & People Management	Billing & Business	Recruitment → onboarding → leave → reviews → training → exits
Customer Service	Billing & Business	Tickets → bugs → requests → refunds → escalations → knowledge
Finance OS (US)	Finance	RIA/broker-dealer onboarding, compliance and advisory
Finance OS (AU)	Finance	AFSL advice, Best Interest Duty, super and AUSTRAC workflows
Aokie Receptionist	AI & Voice	Calls → transcript turns → callers → requests → follow-ups

---

Start in the way that suits you

Path	Best for	Start here
Explore	Seeing complete apps before creating an account	Open the populated live demo
Hosted	Getting started without managing infrastructure	Create an account—free access with bring-your-own AI
Self-hosted	Keeping the full deployment on infrastructure you control	Use the assisted installer below
Desktop + Aokie	Local AI, devices, headless flows and phone calls	Follow the Aokie setup guide

FormLogic defaults to free access. Payments are off by default. Administrators can enable an optional Supporter plan and edit its name, description and price; the default is $5 USD per 30 days, prepaid with no automatic renewal. Free access continues independently of support payments. Plan configuration

Self-host FormLogic

Requirements

Requirement	Version / notes
PHP	8.2+ with pdo_mysql, pdo_sqlite, mbstring, json, openssl and fileinfo
MySQL	8.0+
Node.js	24.19.0 LTS recommended (pinned in .node-version); supported: 22.22.2+ (22.x), 24.15.0+ (24.x), or 26+
Composer	Any recent release

Node.js builds the web client and is also required on servers using native app hosting: its trusted Node host runs the ZIPP VM and SQLite migrations. Standard form scripts and named hosted actions use their packaged sandbox launcher. Native hosting also needs PDO SQLite, prepared backend modules and the generated Softn browser runtime and editor assets.

The frontend test suite uses jsdom 30. Node 20 and older Node 22/24 releases cannot run it. Check node --version before npm ci; use the version in .node-version for the same environment as the manual build and release checks.

Assisted CLI install

git clone git@github.com:f2i-com/formlogic.com.git

cd formlogic.com/formlogic/ui
npm install
# The app engine's runtime comes from Softn's latest GitHub release: the
# hosted runtime, the embedded editors and the native backend runtime,
# fetched, verified and installed in one step. No Softn checkout or build.
node ../../scripts/fetch-softn-release.mjs

# The installer can now build the web client.
cd ..
chmod +x install.sh
./install.sh

The installer creates environment files, generates security keys and prepares the database. Install the shared app host first: every frontend build requires its generated assets, including the build performed by the installer.

Browser installer

Serve the repository from your web root and open:

http://localhost/<your-folder>/formlogic/install.php

Warning

Delete install.php after setup, serve only the backend public/ directory and use HTTPS in production.

For manual development setup, production web-server examples, environment variables, tests and troubleshooting, see formlogic/README.md and DEPLOYMENT.md.

Install the portable app host

FormLogic uses the latest Softn release automatically. From formlogic/ui:

node ../../scripts/fetch-softn-release.mjs
npm run build

The fetch script looks up Softn's latest GitHub release, downloads its softn-formlogic-runtime-<tag>.zip, checks it against its .sha256 and its own manifest, checks it fits this FormLogic (identical ZIPP engine bytes, the same protocol versions, the adapter this tree has vendored) and installs public/hosted-runtime/, the embedded tools in public/app-editors/, and the trusted backend modules in backend/resources/softn-native/. Generated artifacts stay out of Git; include them in the deployment. The prebuild checks verify browser runtime and editor assets before compiling the UI. SOFTN_RELEASE=v0.0.13 installs one release instead of the latest; --check verifies an install without the network; --sync-adapter refreshes the vendored adapter when a release changed it (then commit). A CI run resolves the release once (--resolve-only --frozen softn-frozen.json) and every job installs that frozen record (--frozen), so no job can pick up a Softn release published mid-run; the install is one generation (staged, verified and promoted whole, recovered whole after an interruption) and --check holds every installed file to its recorded inventory. Developers working on Softn itself can still build from a sibling checkout: set SOFTN_REPO and run npm run build:hosted-runtime, npm run build:app-editors and node ../../scripts/prepare-native-runtime.mjs. See docs/ecosystem/SOFTN_RELEASE.md. Hosted apps guide covers private actions, SQLite storage, static-asset headers and backups.

For local development, Vite keeps requests on /api and proxies to http://127.0.0.1:8080. Set VITE_API_PROXY_TARGET to change that target.

Under the hood

Layer	Technology
Web client	React 19, TypeScript, Vite 8, Tailwind CSS 4, Zustand, React Router and Recharts
Builder & flows	dnd-kit, XYFlow, Monaco, ZIPP WASM and Web Workers
API	PHP 8.2+, Slim 4, PHP-DI and Monolog
Data	MySQL for platform metadata, SQLite response databases per form and a separate SQLite database per hosted app
Portable apps	Softn interfaces and client logic, a sandboxed host frame and private backend actions
Sandboxed scripting	ZIPP in a browser worker and a bounded server sandbox, including hosted .logic actions
Desktop	Tauri v2 and Rust; Windows UI plus a headless runtime
Aokie	Rust, WinUSB, Bluetooth HFP/SCO/MAP, ONNX speech and a versioned JSON-RPC plugin contract
Authentication	HttpOnly signed sessions, scoped API keys, OAuth/MCP tokens and optional TOTP MFA

formlogic.com/
├── formlogic/
│   ├── backend/          PHP/Slim API, workers, migrations and storage
│   ├── ui/               React builder, app runtime, dashboards and flows
│   └── native-runtime/   Signed-manifest native application shell
├── docs/                 Architecture, API, MCP, pack and operations docs
└── DEPLOYMENT.md         Production deployment and recovery guide

oaiy.com/                 Desktop services, providers, plugin host and flow runner
softn.com/                Shared app engine, builder and FormLogic host

aokie.com/
├── crates/aokie-plugin/      OAIY plugin and durable event bridge
├── crates/aokie-bluetooth/   HFP/SCO/MAP/PBAP radio runtime
├── crates/aokie-dongle/      Dongle discovery and guarded driver management
├── crates/aokie-ai/          Local ONNX speech runtimes
└── docs/                     Architecture, hardware and frozen contracts

Quality and security gates

Automatic push/PR and scheduled CI checks are currently paused. Run checks locally; retained manual workflows are available from GitHub Actions. Manual packaging still invokes its release verification jobs. OAIY and Aokie maintain their own Rust/Windows checks.

# Backend
cd formlogic/backend
composer test
composer analyse

# Frontend
cd ../ui
npm test
npm run lint
npm run build
npm run test:e2e

# Aokie repository
cargo test --workspace
cargo check -p aokie-plugin --features voice
cargo clippy --workspace --all-targets

Security controls include server-enforced RBAC, HttpOnly session cookies, CSRF protection, endpoint-specific rate limits, optional TOTP MFA, sandboxed user code, SSRF-guarded outbound requests, custom-screen no-egress CSP, signed packages/manifests and a hash-chained audit log. The authenticated Doctor view checks critical production dependencies and configuration after a deploy or restore.

Current beta boundaries

• The hosted service is in public beta.
• The paired desktop (OAIY) currently targets Windows; the web app works across modern browsers.
• Aokie is a Windows hardware beta and only catalogued Bluetooth dongles are supported.
• Aokie auto-answer defaults off and must be explicitly enabled.
• Local models are the default Aokie path; configured remote providers receive the data required for their request.
• Aokie records appointment requests for confirmation unless you deliberately build a flow that performs the final booking.
• Desktop/Aokie Windows release artifacts may trigger SmartScreen until production code signing is completed.
• The Aokie plugin emits SMS records and can send messages; it should not yet be presented as a full mirrored phone inbox.

Documentation

Guide	What it covers
Documentation index	Current guides, task-based entry points and historical design references
Developer setup	Local development, environment variables, tests and web-server configuration
Deployment	Production checklist, backups, workers, health checks and recovery
External API	Scoped API keys and the REST endpoint reference
MCP	Connecting your own AI with scoped access
FormLogic Flows	Graph contract, bindings, execution and run history
Desktop pairing (historical)	How the paired-desktop contract was designed; the app itself is now OAIY
Custom app platform	App logic, custom screens, SDK, connectors and domains
Connected apps	Portable dashboards, sharing forms, Aokie integration and MCP setup
Hosted apps	Softn clients, private .logic actions, SQLite storage and deployment
AI setup and plans	Bring-your-own AI, optional support and administrator controls
Package format	Signed .formlogic packages, manifests and trust
Native runtime	Deep links, signed manifests, connectors and offline queue
Aokie operations	Desktop stack, deployment, diagnostics and event recovery
Aokie troubleshooting	Concrete call, audio, flow and hardware failure modes

License

FormLogic is proprietary, source-available software—it is not open source. Subject to the full LICENSE, you may self-host it, use it for free and modify it for your own use, including to run your own for-profit business. You may not resell FormLogic, offer it as a competing paid/hosted service or charge others to run it without a commercial licence.

Aokie is also proprietary and versioned separately in the Aokie repository.

---

Your forms, apps, data and automations, connected.

FormLogic.com · Documentation · hello@formlogic.com