Frontier Flow

From idea to deployment in under 10 minutes for EVE Frontier automation builders

Frontier Flow is a low-code visual editor for EVE Frontier players who want to design game automation logic without hand-writing smart contract code. Build automation flows on a node canvas, generate deterministic Sui Move output in the browser, validate logic before deployment, and move from concept to contract fast.

For contributors, the repository is set up for fast local iteration with Bun, strict TypeScript, a clear verification pipeline, and project documentation that explains the product, architecture, design system, and contribution workflow.

Table of Contents

• About The Project
• Features
• Built With
• Getting Started
• Usage
• Workflow Screenshots
• Roadmap
• Contributing
• License
• Contact
• Acknowledgments

About The Project

Frontier Flow is designed for players who think visually, iterate quickly, and still need production-ready output. Instead of hand-coding every rule, you build your automation logic by connecting typed nodes that represent events, filters, data accessors, scoring rules, and actions.

The editor is tuned for the EVE Frontier domain and backed by a TypeScript-first frontend, a browser-based compilation pipeline, and deterministic code generation. That means you can:

• sketch contract logic as a flowchart
• validate your graph before wasting time on broken builds
• inspect compile feedback directly in the UI
• generate readable, predictable Move code ready for the next deployment step

The Visual view with a saved contract open, typed connections on the canvas, node categories in the toolbox, and build status in the footer.

Features

• ⚡ Build automation flows visually with a drag-and-drop node editor
• 🧠 Translate EVE Frontier logic into deterministic Sui Move code
• 🛡️ Catch disconnected nodes, missing inputs, and invalid graphs early
• 🔁 Auto-compile on idle with manual build control when you want it
• 🎯 Surface compiler diagnostics back onto the exact canvas nodes involved
• 🚀 Move from idea to deployment-ready output in under 10 minutes
• 🧪 Validate behavior with unit, component, and end-to-end tests

Built With

Major project foundations include:

• Bun
• TypeScript
• React 19
• Vite
• Tailwind CSS 4
• React Flow via @xyflow/react
• @zktx.io/sui-move-builder for in-browser Move compilation

Getting Started

👋 Contributor quick start: if you want to work on the codebase, the shortest path is bun install, bun run dev, then bun run verify before you open a pull request. More information about security and quality standards available in CONTRIBUTING.md.

Prerequisites

Make sure the following tools are available locally:

• Bun >= 1.0.0
• TypeScript 7+
• Git

You can verify your environment with:

bun --version
tsc --version
git --version

Installation

1. Clone the repository.
2. Install dependencies.
3. Start the development server.

git clone https://github.com/Scetrov/frontier-flow.git
cd frontier-flow
bun install
bun run dev

Note

If you are using a forked repository, make sure to set the upstream remote to the main repository for future updates and sync changes before opening a pull request.

For a local quality gate before opening a PR:

bun run verify

Usage

Start the app locally

bun run dev

Open http://localhost:5179 or the local URL printed by Vite, then:

1. Stay in the Visual view and drag a trigger node such as Aggression or Proximity onto the canvas.
2. Add logic, data, and action nodes, then connect their typed sockets.
3. Configure any node that needs structured values.
4. Wait for auto-compile or click Build.
5. Switch to the Code view to inspect the generated source.

Run tests

bun run test

Run the CI-style test suite once:

bun run test:run

Run end-to-end tests:

bun run test:e2e

Run the opt-in real WASM compiler integration check:

bun run test:real-wasm

This executes a Bun-based integration script that feeds reference graph fixtures directly into the compiler pipeline and asserts that valid bytecode is produced.

Run the focused reference-regression and authorization-readiness checks:

bun run test:run -- src/__tests__/compiler/referenceDagValidation.test.ts
bun run test:e2e -- generated-contracts.spec.ts authorization-readiness.spec.ts

Build for production

bun run build

Fetch the pinned world-contracts reference checkout only when you explicitly need it:

bun run build:with-world-contracts

This populates vendor/world-contracts at the pinned upstream tag used for local reference work, then runs the normal production build. The vendor/ directory is intentionally ignored and is not part of the app's tracked runtime dependencies.

Refresh the pinned locally hosted Sui framework mirror used by the browser compiler when you need to update the shipped upstream sources:

bun run fetch:sui-upstream-sources

This fetches the pinned MystenLabs/sui package tree via git, copies the framework sources into public/upstream-sources/, and lets the app serve those files locally instead of hitting raw.githubusercontent.com during normal compilation.

Typical contributor workflow

# install dependencies
bun install

# start the local app
bun run dev

# run static checks and tests
bun run lint
bun run typecheck
bun run test:run

# fetch the pinned world-contracts checkout only if you need that local reference repo
bun run fetch:world-contracts

# refresh the pinned locally hosted Sui framework mirror used by the browser compiler
bun run fetch:sui-upstream-sources

Workflow Screenshots

The current UI follows a five-stage workflow: compose the graph in Visual, configure node data, review generated output in Move, deploy to the selected target, and confirm the published package metadata.

1. Compose the contract graph

Start in the Visual view by dragging Frontier nodes from the toolbox onto the canvas, wiring typed sockets, and saving the flow as a named contract snapshot. This is the main authoring stage, where triggers, logic, data extractors, and actions are combined into a deterministic graph.

2. Configure node-specific data

Open the node editor when a graph element needs structured input. In this example, the List of Ship node lets you select one or more live-world ship entries that feed downstream target matching and priority logic.

3. Inspect generated Move output

Switch to the Code view to inspect the generated source before deployment. The top bar keeps Build and deploy-target controls available while the source panel shows the exact Move module produced from the graph, with compiler diagnostics kept alongside the selected source file when the build reports issues.

4. Track deployment progress

When you deploy, Frontier Flow surfaces each stage of the pipeline in a modal: validation, preparation, signing, submission, and confirmation. Instead of a single opaque loading state, the UI shows which step is active and which steps have already completed.

5. Confirm the deployed package

After the transaction finalizes, the modal switches to a completed state and shows the target environment plus the published package ID. This is the handoff point for follow-up testing, upgrades, or any workflow that needs confirmed deployment metadata.

Roadmap

• 🧩 Expanded node packs for more EVE Frontier mechanics and strategies
• 📦 Shareable contract templates and starter flow presets
• 🔐 Wallet-driven deployment workflow directly from the editor
• 👥 Collaboration-friendly features for team iteration and review
• 📊 Richer compile insights, graph analytics, and optimization hints
• 🌐 Better onboarding, documentation, and example contract libraries

See the open issues for active work and proposed improvements.

Contributing

Contributions are welcome from developers, UI engineers, tool builders, and EVE Frontier players with strong workflow ideas.

To contribute:

1. Fork the repository.
2. Create a feature branch.
3. Make your changes.
4. Run the local checks.
5. Commit with a clear message.
6. Push your branch.
7. Open a pull request.

git checkout -b feat/your-improvement
bun run verify
git commit -m "feat: describe your change"
git push origin feat/your-improvement

Before contributing, please review:

• CONTRIBUTING.md
• SECURITY.md, including private vulnerability reporting
• REPOSITORY-GOVERNANCE.md, including protected-branch and dependency-update procedures
• WORLD-PACKAGE-REFERENCE-RUNBOOK.md, for maintaining remote deployment World package references
• CODE_OF_CONDUCT.md

License

Distributed under the MIT License. See LICENSE.md for the full text.

Contact

• Website: scetrov.live
• GitHub: github.com/Scetrov
• Project: github.com/Scetrov/frontier-flow

Important

If you need to send me a secure message, please use the GPG key for GPG, or SSH key for Age.

Acknowledgments

• Fenris Creations and the EVE Frontier universe for the domain inspiration
• The React and TypeScript ecosystems for a solid frontend foundation
• The @xyflow/xyflow maintainers for the node-based editing engine
• The Sui and Move tooling ecosystem for contract compilation workflows
• zktx.io for the awesome @zktx.io/sui-move-builder without which this wouldn't be possible
• The Bun, Vite, Playwright, and Vitest projects for keeping local iteration fast
• Netlify and GitHub Pages for hosting the live deployment and providing a free tier for open-source projects

If Frontier Flow helps your workflow, star the repository and share your feedback.

My other projects

While I am deeply proud of Frontier Flow, I also maintain a few other open-source projects that may be of interest:

• efctl - is a CLI tool for EVE Frontier builders that helps you manage your local development environment, build and deploy contracts, and interact with the game world from the command line. Think of it as the Docker Composer for EVE Frontier.
• EVE Frontier Rust - a series of Rust crates and deployment patterns for deploying your own pathfinding logic inside your application.
• EVE Frontier Datasets - datasets extracted from the EVE Frontier client a consoldated SQLite database for use in your own applications.

More examples of my work are available on scetrov.live and GitHub.