100% Native AOT • Zero External Dependencies • .NET 10 Declarative Framework

Compress Months of Enterprise Development to 15 Minutes.

Forget redundant controllers and DTO ceremony. Derive Web UI, REST API, Cryptographic Licensing, and 5 Standalone Server Batteries with declarative C# records.

$ dotnet new weaver-app -n MyEnterpriseApp
bash / zsh
1
2
3
4
5
6
7
8
9
10
11
12
13
[UiAction(Group = "Finance", DisplayName = "Approve Payment", Icon = "credit-card")]
[RequireDualApprovalIf("Amount > 50000")]
[FieldSecurity("InternalBudgetNotes", Role = "CFO")]
public sealed record ApprovePayment(
    string InvoiceId,
    decimal Amount,
    string InternalBudgetNotes
) : IMechanismAction<ApproveResult>;

// Generated at compile-time by Roslyn with zero reflection:
// 1. /api/finance/approve-payment REST Endpoint and OpenAPI Schema
// 2. Dynamic React Form Modal and Field Masking
// 3. HMAC-SHA256 Merkle Audit Trail and Dual-Control Approval Pool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
POST /api/finance/approve-payment HTTP/1.1
Host: api.codechu.com
Authorization: Bearer eyJhbGciOiJSUzI1NiIs...
Content-Type: application/json

{
  "invoiceId": "INV-2026-9481",
  "amount": 75000.00,
  "internalBudgetNotes": "Infrastructure expansion approved."
}

HTTP/1.1 202 Accepted
{
  "actionStatus": "PendingDualApproval",
  "approvalTrackingId": "APPR-8821-X",
  "requiredSignatures": 2,
  "currentSignatures": 1,
  "auditMerkleHash": "7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import React from 'react';
import { useMechanismAction, ActionModal } from '@mechanismweaver/cockpit';

export const ApprovePaymentAction = () => {
  const { invoke, isDualApprovalRequired, isLoading } = useMechanismAction('ApprovePayment');
  
  return (
    <ActionModal 
      title="Approve Payment" 
      icon="credit-card"
      securityGroup="Finance"
      onExecute={(payload) => invoke(payload)}
    >
      {/* Schema-derived dynamic form, 4-Eyes dual approval lock */}
    </ActionModal>
  );
};
⚡ Live Pipeline Engine Test live how a 1-line C# declaration is compiled by Roslyn and executed in microseconds:
1
Tenant Isolation
TenantId: tenant-810
0.01 ms
2
Validation
Amount > 0, Valid
0.03 ms
3
Dual-Control Gate
Amount > $50k (CFO)
0.02 ms
4
Merkle Audit
HMAC-SHA256 #4092
0.08 ms
5
Roslyn Handler
Zero Reflection (AOT)
0.24 ms
15-MINUTE PROOF

Compress Months of Development to 15 Minutes

See how a full production-ready enterprise app is deployed from scratch in 4 steps.

⏱️ 00:00 - 02:00
1. Scaffold Skeleton
dotnet new weaver-web -n EnterpriseApp

DI container, pipeline, and modular core are scaffolded in 2 seconds with zero ceremony.

⏱️ 02:00 - 06:00
2. Declare 1-Line Record
[UiAction(Group="Finance")] [RequiredDualApprovalIf("Amount > 50000")] public record ApprovePayment(...) : IMechanismAction;

Define business rules, maker-checker authorization, and layout masks via declarative C# attributes.

⏱️ 06:00 - 10:00
3. Compile via F5 / dotnet run
dotnet run

Roslyn compile-time source generator emits REST endpoints, OpenAPI 3.1, and React UI form modals.

⏱️ 10:00 - 15:00
4. Deploy to Production (Native AOT)
dotnet publish -r linux-x64 --self-contained

Ultra-lean single binary with 57 MB RAM and 0.13 ms CPU latency live on VPS!

F5 OUT-OF-THE-BOX COCKPIT

What Do You See When You Press F5?

Fully turnkey without writing any frontend code; 57 MB RAM, modern React 18, and zero reflection!

01

Enterprise DataGrid & PivotGrid

Live search, pagination, dynamic column reordering, visual FilterBuilder, and 1-click Excel/CSV export.

02

Dynamic Action & Form Modals

Auto-derived form modals with [UiMask], [LookupDependsOn], [UiRequiredIf], and live server-side validation.

03

Maker-Checker Dual Approval Pool

Automated maker-checker queue that pauses high-risk actions (> $50k) until authorized by CFO.

04

Immutable Merkle Audit Trail

Who modified what, when, and from where; provable cryptographic HMAC-SHA256 Merkle audit trail.

05

Visual Report Studio & ESC/POS

Drag-and-drop banded report designer, 45° watermark engine, PDF/SVG, and thermal ESC/POS receipt engine.

06

Resilient Outbox & DLQ Recovery

Respectful Rate Limiting for external APIs, background spooler, and 1-click Dead-Letter recovery.

CLI PROJECT TEMPLATES

4 Enterprise Batteries via dotnet new

Lightweight, dependency-free standalone templates tailored for every workload.

weaver-web
Flagship Web & Cockpit

Full React Cockpit UI, REST API, OpenAPI 3.1, Maker-Checker Approval Pool, and Merkle Audit Trail.

dotnet new weaver-web -n MyPortal
weaver-service
Headless API & Microservice

UI-free, microsecond latency backend engine with high-throughput REST and RESP protocol support.

dotnet new weaver-service -n CoreApi
weaver-worker
Resilient Queue & Outbox

HTTP Outbox Spooler, Respectful Rate Limiter, Dead-Letter Queue quarantine and automatic recovery.

dotnet new weaver-worker -n JobSpooler
weaver-module
Plug-and-Play Business Module

Isolated business action library that can be mounted into any Weaver host in a single line of code.

dotnet new weaver-module -n Billing

⚡ 100% Native AOT & Zero Reflection

Compile-time Roslyn Source Generators producing zero-reflection REST and Cockpit surfaces.

🛡️ Asymmetric Ed25519 & RSA Licensing

Air-gapped enterprise licensing engine with SHA-256 HMAC Merkle tree verifier.

🚀 5 Standalone Server Batteries

OIDC Auth, Redis RESP Cache, S3 Storage, Merkle Ledger, and Http Outbox Spooler.

🔒 Dual-Control Approval Pool (4-Eyes)

Automated dual-approval governance mechanism for sensitive operational actions.

🌐 Multilingual Declarative Portal & CMS

Built-in TR/EN/DE localization, automated SEO, and lightweight Markdown CMS blog engine.

📊 Live OpenTelemetry & Grafana Ready

Prometheus metrics, distributed traces, and real-time execution telemetry.

ARCHITECTURAL COMPARISON

The Others & Traditional .NET vs. MechanismWeaver

Why spend hundreds of hours writing redundant boilerplate or struggling with heavy monoliths?

Feature / Metric The Others (Traditional .NET / Monolith) ⚡ Codechu MechanismWeaver
Files Per New Action 50+ Files (Controller, DTO, Service, Validator, React Component) Single 1-Line C# Declaration
Runtime Memory (RAM) ~400 MB - 800 MB (The Others / Heavy Reflection) ~57.2 MB (100% Native AOT)
Cold Start Latency 5.0 - 12.0 Seconds (The Others / Heavy Monolith) 42 Milliseconds (Instant Ready)
UI Technology Legacy WebForms / Blazor Server Modern React 18, WebGL, SignalR Cockpit
Cryptographic Audit Trail Standard SQL Log Table HMAC-SHA256 Merkle Audit & Dual-Control Gate
External Dependencies (NuGet) Dozens of 3rd party packages & heavy DLLs 0 External Dependencies (BCL-Only Core)
Licensing & Cost Thousands of $/developer/yr or Forced SaaS Perpetual Fallback (You Own It Forever, Autonomous)
PERPETUAL FALLBACK

You Own What You Buy Forever

No subscription trap. 1 Year of updates included with perpetual fallback.

Indie & Founder

$299 / one-time
1 Year of Updates & Perpetual Fallback
  • Single Developer License
  • Unlimited Projects & Deployments
  • 5 Built-in Server Batteries
  • Roslyn Source Generator & Cockpit
  • Community & Discord Support

Enterprise Unlimited

$2,499 / one-time
Lifetime Updates & Custom SLA
  • Unlimited Developer Seats
  • Full Source Code Access
  • Custom Adapter Consulting
  • Air-gapped Deployment Support
  • 24/7 SLA Guarantee
FREQUENTLY ASKED QUESTIONS

Everything You Need to Know

Transparent answers regarding architecture and perpetual licensing.

What is the Perpetual Fallback licensing model?
When you purchase MechanismWeaver, you receive 1 year of all major and minor updates. If you choose not to renew, you own the latest version forever with zero usage restrictions.
Is MechanismWeaver truly zero external NuGet dependencies?
Yes! Core modules (Kernel, Abstractions, Compositor) only rely on the .NET 10 Base Class Library (BCL), eliminating dependency hell and supply-chain vulnerabilities.
How does Native AOT support work?
Instead of runtime reflection, Roslyn Source Generators generate model binding, validation, and action dispatchers at compile time, achieving 42ms cold start and <50MB RAM.
Can I integrate this with existing ASP.NET Core apps?
Absolutely. MechanismWeaver operates as standard ASP.NET Core middleware via `services.AddMechanismWeaver()` and `app.MapMechanismsUi()`.