WUF
WHAT'S UP FUDD
Ship calmer software
High-DX functional webapps • Evolutionary adoption • Reliable Results

Upgrade your stack for SPPM without rewriting everything.

FUDD turns “strong but niche” tools into a modern platform: typed UI + typed server + typed SQL, with an evolutionary path from existing code. Built for experienced developers and CTOs who want fewer regressions, calmer deployments, and predictable performance.

Choose your feature
tap to preview outcomes
Internal tools: ship fast, refactor safely
Predictable UI state, SQL you can read, and compiler-guided change. Cut the glue-code tax.
Typed UI modelTyped SQL bindingsSSR-firstHot reload (target)
Default
SQL-first
UI model
Elm-like
Server
Haskell
Adoption
Evolutionary
Stop shipping strings to the database
Prefer build-time validated SQL + typed bindings. Keep performance predictable and correctness visible.
A framework is a loop
FUDD’s obsession: the dev loop! scaffold → run → edit → inspect → ship—without chaos.
SPPM cockpit
Security
Fewer footguns
Productivity
Less glue
Performance
Predictable SSR
Maintenance
Compiler-guided
Try the “instant clarity” test
If your DB access or UI state can’t be explained in 60 seconds, it’s probably too implicit.
tapthe 3D nodes to reveal what FUDD makes explicit
Typed SQL (taste)
-- Query is validated at build-time (shape + params)
select_image :: Session -> UUID -> IO (Maybe Image)
select_image s imgId =
runQuery s [sql|
  SELECT id, path, caption
  FROM images
  WHERE id = $1
 |] (Only imgId)
No ORM by default. Keep SQL readable. Bind values safely.

Why FUDD

AI accelerates code creation—while also accelerating new failure modes. FUDD’s posture is simple: make the system legible, make change safe, and make performance predictable.

SPPM is the scoreboard

Every feature must pay rent in at least one of: Security, Productivity, Performance, Maintenance.

Pro-tip
Frameworks win when their defaults prevent your worst week.
Security

Centralized request handling, explicit action boundaries, fewer injection surfaces, safer data flow.

Productivity

Scaffolding that matches how you build. Less glue-code. Clear errors. Fast iteration loop.

Performance

SSR-first, compact templates, SQL that’s easy to optimize, predictable server execution.

Maintenance

Compiler-guided change + explicit boundaries reduce regressions and “unknown unknowns”.

SPPM radar
interactive • tap/drag

How it works

FUDD is a platform, not a pile of libraries. It standardizes the loop: project structure → server → UI → actions → SQL.

  1. 01
    Wapp conventions
    Predictable structure that tooling can understand instantly.
  2. 02
    EasyWordy runtime
    Sessions, routing, SSR pipeline, introspection hooks.
  3. 03
    Fuddle UI
    Elm-like model/update/view with SSR and controlled interop.
  4. 04
    Actions + typed SQL
    UI triggers structured server actions; DB logic stays explicit and optimizable.
The gamer analogy

Most stacks build a character by adding random gear (libraries). FUDD builds a skill tree: you unlock reliability and speed by making assumptions explicit.

Ecosystem map
drag nodes • tap to pin
Tap a node
See how each component improves the loop.
DX target
React/Next convenience, with fewer runtime surprises.
Interop posture
Allow JS where needed, but keep it boxed and explicit.

Ecosystem

Explore the core parts of FUDD: the SPPM lens, the big-picture thesis, the Fuddle runtime, WordPress upgrade paths, and the community guild.

A measurable lens
SPPM

Security • Productivity • Performance • Maintenance — and how FUDD improves them in real webapps.

metricsguardrailsbenchmarks
/sppm.htmlOpen →
The big map
Vision

Why formal logic + AI + migration tooling must ship together to make high-correctness feel mainstream.

systemsroadmaptradeoffs
/vision.htmlOpen →
Elm, modernized
Fuddle

Server-side rendering, templating, multilingual UI primitives, and a clean path to powerful interactivity.

SSRtemplatingDX
/fuddle.htmlOpen →
Drop-in replacement
WordPress transition

Keep your site running while you progressively replace PHP hotspots with compiled, safer and faster components.

incrementalcompatperformance
/wordpress.htmlOpen →
Guild energy
Community

A welcoming builder culture with merit-based stewardship, transparent progress, and playable learning paths.

governancequestssupport
/community.htmlOpen →

Migration without the rewrite tax

FUDD is designed for co-existence: stronger components can wrap and replace weaker ones progressively, with validation and rollback paths.

Pick a migration path
NextJS / React: replace slices, not the whole
Start with a single route or admin area. Keep the rest untouched. Measure outcomes before expanding.
Migration timeline (game quest)
tap nodes
Quest 0
Wrap + observe
Add visibility, stabilize interfaces, reduce surprise behavior.
Quest 1
Replace static surfaces
Extract templates, improve SSR and caching, keep logic intact.
Quest 2
Replace hot paths
Target the endpoints that cause the most regressions or cost.
Quest 3
Retire legacy safely
Move remaining logic to strong boundaries; keep rollback until stable.
Rule
No phase proceeds without a measurable SPPM gain.

Roadmap (honest status)

FUDD uses explicit maturity levels: GA, Beta, Alpha, Research. We publish “exit criteria” so you can judge risk quickly.

Current focus
  • Webapp loop: Wapp → EasyWordy → Fuddle → Actions → Typed SQL
  • DX: hot reload, introspection, actionable errors
  • Migration wedge: replace slices, not systems
Maturity grid
Wapp conventions
project structure, predictable tooling
Beta
Typed SQL pipeline
query verification + bindings
Beta
Action bridge
UI → server with tracing + auth
Alpha
WordPress Phase 0
hardening + caching + observability
Research
Promise
If it’s not stable, we label it. If it’s stable, we version it.

FAQ

Is this “just Haskell on the server”?

No. FUDD standardizes the full loop (project structure, UI model, action bridge, SQL posture, tooling) so teams can ship without stitching everything manually.

Do I have to abandon React / existing code?

No. The adoption goal is evolutionary: replace slices, keep rollback, measure SPPM gains before expanding.

Where does JavaScript fit?

Use JS for what it’s good at (specialized UI or libraries). FUDD tries to make interop explicit so it doesn’t become the default glue for everything.

Ready to test the loop?

Get beta access + the CTO briefing deck

We’ll send a short quickstart and a clear status matrix. No spam. If you’re migrating a legacy stack, we’ll include the “thin wedge” playbook.

SPPM-focusedSQL-firstSSR-firstEvolutionary migration