Both scaling source-code and scaling deployments are difficult. They need not be.

I build tools for a different philosophy of software engineering… one that rejects the bloated, non-native defaults of the modern stack.

• Restore Monolithic Velocity: Polyglot systems—separate backend(s) from frontend(s)—create a "synchronisation tax" that kills development speed. My cdd compilers automate this away, making multi-language development as fast as a Ruby on Rails or Django. And synchronises tests and docs also; improving software quality.
• Demystify Deployment: Software deployment is not as complex as the industry makes it seem. My verMan.io toolchain provides a direct path to reproducible, cross-platform, bare-metal environments, making containers a choice, not a mandate.
• Outpace ML Fragmentation: The pace of ML innovation is relentless. My kitchenSink.ai compilers treat entire ML frameworks as its search space. And my ml-switcheroo project translates code betwixt ML frameworks.

My cdd compilers are the engine for restoring monolithic velocity. Each one works bidirectionally: you can generate typed code from a specification, or derive a specification from well-structured code. This keeps your polyglot architecture perfectly synchronised.

graph LR
    subgraph "A. Compilers"
        PyComp["cdd-python"]:::blue
        RsComp["cdd-rust"]:::red
        CComp["cdd-c"]:::yellow
        KtComp["cdd-kotlin"]:::green
        EtcComp["..."]
    end

    subgraph "B. Specification"
        OpenAPI["<b>OpenAPI</b>"]:::navy
    end
    
    PyComp <-- "to/from spec" --> OpenAPI
    RsComp <-- "to/from spec" --> OpenAPI
    CComp <-- "to/from spec" --> OpenAPI
    KtComp <-- "to/from spec" --> OpenAPI

    %% Styling
    classDef blue fill:#4285f4,stroke:#20344b,stroke-width:2px,color:#ffffff
    classDef green fill:#34a853,stroke:#20344b,stroke-width:2px,color:#ffffff
    classDef yellow fill:#f9ab00,stroke:#20344b,stroke-width:2px,color:#ffffff
    classDef red fill:#ea4335,stroke:#20344b,stroke-width:2px,color:#ffffff
    classDef navy fill:#20344b,stroke:#a0a0a0,stroke-width:1px,color:#ffffff

This toolkit eliminates boilerplate for data models, API clients | servers routes, and tests, enabling maximum code reuse while demanding truly native performance.

Repository	Language	Client or Server	Extra features	OpenAPI Standard	CI Status
cdd-c	C (C89)	Client	FFI	OpenAPI 3.2.0
cdd-csharp	C#	Client	CLR	OpenAPI 3.2.0
cdd-go	Go	Client		OpenAPI 3.2.0
cdd-kotlin	Kotlin (Multiplatform)	Client	Admin UI	OpenAPI 3.2.0
cdd-python	Python	N/A (server building blocks)	CLI ↔ SQL ↔ Pydantic ↔ docs ↔ JSON-schema	N/A
cdd-python-client	Python	Client		OpenAPI 3.2.0
cdd-rust	Rust	Server	OpenAPI rendering	OpenAPI 3.2.0
cdd-sh	Shell (/bin/sh)	Client		OpenAPI 3.2.0
cdd-swift	Swift	Client		OpenAPI 3.2.0
cdd-web-ng	TypeScript	Client	Auto-Admin UI	OpenAPI 3.2.0 & Swagger 2

Application: Outpacing ML The cdd-python compiler powers the kitchenSink.ai project. My ml-switcheroo project translates translates models, operations, lifecycles, and general I/O betwixt frameworks.

Applications, databases, and ML can be deployed with verMan.io—my answer to the heavyweight, container-first paradigm. You can still use this within containers, but you are not limited to non-native abstractions like Docker.

graph TD
    subgraph " "
        Mgrs["<b>Polyglot Version Managers</b><br>Go | Rust | C | Shell"]:::blue
    end

    subgraph " "
        Cloud("Cloud VMs"):::yellow
        Native("Bare Metal<br>Win, Linux, BSD..."):::yellow
        Docker("Docker"):::yellow
    end

    Mgrs --> Cloud
    Mgrs --> Native
    Mgrs --> Docker

    %% Styling
    classDef blue fill:#4285f4,stroke:#20344b,stroke-width:2px,color:#ffffff
    classDef yellow fill:#f9ab00,stroke:#20344b,stroke-width:2px,color:#ffffff
    classDef navy fill:#20344b,stroke:#a0a0a0,stroke-width:1px,color:#ffffff

This toolkit uses lightweight, purpose-built package managers for direct and efficient deployment. These work with or without Docker, Kubernetes, etc.

• Core Managers: rvm/nvm-style package managers written in Go, Rust, and C for consistent cross-platform dependency and version management.
• Orchestration Layer: A mature Python toolkit to automate deployments across 50+ cloud providers.