https://github.com/zot/frictionless
You and Claude using apps together. Evolving them while they run. Making. Sharing. Downloading.
https://github.com/zot/frictionless
Last synced: 2 months ago
JSON representation
You and Claude using apps together. Evolving them while they run. Making. Sharing. Downloading.
- Host: GitHub
- URL: https://github.com/zot/frictionless
- Owner: zot
- License: mit
- Created: 2025-12-23T16:44:44.000Z (6 months ago)
- Default Branch: main
- Last Pushed: 2026-02-13T00:56:33.000Z (4 months ago)
- Last Synced: 2026-02-13T09:55:33.814Z (4 months ago)
- Language: Lua
- Homepage:
- Size: 1.17 MB
- Stars: 5
- Watchers: 0
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Frictionless
**Version: 0.29.0**
**A personal software ecosystem for Claude. Share the love. Or steal it.**
Chat with Claude to build apps. Use them together. Evolve them live. Claude runs parts of your app. Your code and Claude talk to each other. Ask Claude for improvements and Claude makes them appear; the app just stays running. Paste a job URL: Claude scrapes the details, fills the form, finds the salary and HQ even when they're not listed.
Frictionless apps are **fully hot-loadable**. Lua backend, HTML templates. No recompiles. No restarts.
And your apps can even **integrate with Claude**: your apps poke Claude and Claude pokes back. Right in the state.
In other words, **Claude has full access to the running app**. It can see and change values, call functions, even update the app as it runs without needing reloads.
Apps for
- **Quality of life** — tame complex tasks with forms and buttons
- **Claude Code life** — point, click, Claude makes it so
- **UNIX life** — UIs for UNIX tools
- **Life beyond Claude Code** — expenses, habits, projects, whatever
- **Dashboards** — surface info at a glance
- **Prototypes** — functional wireframes at a fraction of the tokens
What does **"fully" hot-loadable** mean?
- Both front-end changes and backend changes are hot-loadable.
- All your state is in the backend and hotloading preserves it.
- You rename a field of a prototype, all its instances' fields get renamed.
- Yeah even structural changes to your data. *That's* what **fully hot-loadable** means.
[](https://youtu.be/Wd5n5fXoCuU)
## How It Works
Built on [ui-engine](https://github.com/zot/ui-engine). Less complexity → fewer tokens:
- **No API layer** — no endpoints, no serialization, no DTOs
- **No frontend code** — just HTML templates with declarative bindings
- **No sync wiring** — change backend data, UI updates automatically—no code to detect or push changes
Claude writes your app logic and skips everything else. See [overview](docs/OVERVIEW.md) for details.
## Usage
Once installed, use `/ui show` to show the Frictionless console. You can build apps in the console.
Frictionless uses your project's `.ui` directory for its apps and content.
### Building UIs in the CLI
Ask Claude to build a UI:
```
/ui-thorough make a contacts app with search and inline editing
```
Or display an existing app:
```
/ui show contacts
```
### Using the App Console
The app-console is your home base for managing Frictionless apps. Use `/ui show` to open it.
**Downloading apps from GitHub:**
Click the GitHub icon in the header to download apps directly from GitHub repositories.
**Viewing app details:**
Select an app to see its requirements, open it, test it, or analyze it with Claude.
The bottom panel has two tabs:
- **Chat** — talk to Claude about the selected app
- **Lua** — run Lua code directly in your app's environment
### Standalone Mode
Run frictionless independently for development or testing changes to Frictionless itself:
```bash
frictionless serve --port 8000 --mcp-port 8001
frictionless serve --port 8000 --mcp-port 8001 --dir /path/to/ui-dir
```
The `--dir` option specifies the working directory for Lua scripts, viewdefs, and apps. Defaults to `.ui`.
The `--mcp-port` is only needed if you want to connect it to Claude.
### Bundling
Create custom binaries with your site embedded:
```bash
frictionless bundle site/ -o my-ui-dir # Create bundled binary
frictionless ls # List bundled files
frictionless cat index.html # Show file contents
frictionless cp '*.lua' scripts/ # Copy matching files
frictionless extract output/ # Extract all bundled files to current directory
```
## Available Apps
Download these from the app-console's GitHub panel:
| App | Description |
|-----|-------------|
| [Job Tracker](https://github.com/zot/frictionless/tree/main/apps/job-tracker) | Track job applications through the hiring pipeline. Paste a URL and Claude scrapes the details. |
## Documentation (in .ui by default)
- **[Intro](install/resources/intro.md)** — Introduction and overview
- **[Platform Reference](install/resources/reference.md)** — Architecture, tools, and quick start guide
- **[Viewdef Syntax](install/resources/viewdefs.md)** — HTML template bindings (`ui-*` attributes)
- **[Lua API](install/resources/lua.md)** — Class patterns and globals
- **[Agent Workflow](install/resources/mcp.md)** — Best practices for AI agents
- **[Themes](install/resources/themes.md)** — Theme switching and customization
## Installation
Tell Claude:
```
Install using github zot/frictionless readme
```
To install manually:
```bash
# Download (replace OS/ARCH: linux-amd64, linux-arm64, darwin-amd64, darwin-arm64, windows-amd64)
mkdir -p {home}/.claude/bin
curl -L https://github.com/zot/frictionless/releases/latest/download/frictionless-linux-amd64 -o {home}/.claude/bin/frictionless
chmod +x {home}/.claude/bin/frictionless
cd {your-project}
# Add Frictionless to your project
claude mcp add frictionless -- {home}/.claude/bin/frictionless} mcp
# Initialize the project
{home}/.claude/bin/frictionless} install
# Add the playwright MCP server to your project for better debugging
claude mcp add playwright -- npx @playwright/mcp@latest
```
## Future Directions
### App Permissions
Lua apps have filesystem access via `io.open`, which allows reading files without Claude Code permission prompts. While convenient, this could be misused to explore directories the user hasn't explicitly shared.
**Planned guardrails:**
- Apps declare required permissions in a manifest (e.g., `app.json`)
- Permissions scoped to specific paths: `.claude/`, project root, etc.
- User approves permissions on first run
- Sandbox enforcement in the Lua environment