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.

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.

Application: Outpacing ML The cdd-python compiler powers the kitchenSink.ai project, which translates models between 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.