HydraCode: An IDE That Lets You Program in Your Own Language

An experimental, VS Code-inspired IDE that transforms human-language programming into real, executable code.

HydraCode is an experimental desktop IDE designed to make programming more accessible by allowing developers to write code using keywords from their native language.

Developed as part of the HydraCode project, HydraCode combines a transpilation engine with a fully featured code editor, enabling users to write programs in languages such as Spanish, Italian, French, Portuguese, and Japanese, then translate them into executable code in Java, C, C++, Python, and Go.

The project explores an important question: what if learning to program did not require learning English syntax first?

Rather than introducing another programming language with an entirely new syntax, HydraCode adapts familiar programming concepts to human languages, helping beginners focus on understanding logic and problem-solving instead of memorizing unfamiliar keywords.

Programming Without the Language Barrier

At its core, HydraCode is a transpiler integrated into a desktop development environment.

For example, a user can write the following code using Spanish keywords:

si (x == nulo) {
    sistema.imprimir("hola");
}

HydraCode transforms it into valid Java code:

if (x == null) {
    System.out.println("hola");
}

This process goes beyond simple text replacement. The transpilation engine distinguishes actual source code from strings and comments, preventing words inside those sections from being incorrectly translated.

It also handles word boundaries across different writing systems, allowing mappings to work with non-ASCII characters, including Japanese keywords.

A Language-Agnostic Architecture

One of HydraCode’s main design principles is extensibility.

Instead of hardcoding a fixed list of supported human languages, the project uses a centralized LanguageRegistry and reusable HumanLanguageMapping data structures.

Each mapping defines the relationship between human-language keywords and their corresponding programming-language constructs.

This architecture allows the editor’s features to adapt dynamically to the active language, including:

• Code transpilation.
• Autocompletion.
• Hover documentation.
• Live syntax diagnostics.
• Code-to-blocks conversion.
• Visual programming through Blockly.

Adding a new human language is therefore primarily a matter of defining its mapping data, rather than implementing a separate transpilation engine.

This approach makes HydraCode a foundation for experimenting with programming in different natural languages.

More Than a Transpiler: A Complete Development Environment

What started as a compiler-related project has evolved into a desktop development environment inspired by Visual Studio Code.

HydraCode combines several programming tools into a single application, allowing users to write, execute, organize, and manage their projects without constantly switching between applications.

Multi-Language Code Execution

HydraCode supports running programs written in several programming languages directly from the editor.

Its execution environment includes Java, Python, C, C++, JavaScript, TypeScript, Go, Rust, Ruby, and PHP.

For languages such as C, C++, Java, and Python, the IDE provides an interactive terminal powered by node-pty and ConPTY.

This allows programs to receive user input through standard input, supporting operations such as scanf, input(), and cin.

The goal is to provide a practical programming environment where users can experiment with their code and observe its behavior immediately.

Visual Programming with Blockly

HydraCode also includes a visual programming editor built with Blockly.

Instead of writing every instruction manually, users can construct programs by combining blocks representing programming concepts.

The visual editor uses a generic generator driven by each language’s blockTemplate, allowing it to adapt to registered language mappings.

This means visual programming is not restricted to a single human language. The same underlying system can generate code using different registered vocabularies.

By combining text-based and block-based programming, HydraCode provides different ways to approach the same programming concepts.

Intelligent Editing Without a Full Language Server

The IDE implements a lightweight intelligence system inspired by features commonly found in modern code editors.

Its LSP-lite functionality includes:

• Autocompletion based on the active vocabulary.
• Hover hints for supported keywords.
• Live diagnostics for basic syntax issues, including unbalanced braces, parentheses, and strings.

These features are generated dynamically from the active language mapping, without requiring a dedicated language server for every supported language.

This keeps the architecture flexible while providing useful feedback during development.

AI-Assisted Voice Programming

HydraCode includes an AI voice interpreter that allows users to describe what they want their program to do.

The workflow combines speech recognition through Vosk with a user-configurable, OpenAI-compatible language model endpoint.

The recognized description is processed by the language model and converted into valid HydraCode source code, which is streamed into the editor.

This feature explores an alternative way of interacting with programming environments, particularly for users who may find writing code manually challenging.

Integrated Git and File Management

The IDE also includes tools for managing real software projects.

Its Git integration provides source control functionality directly within the editor, while its file explorer follows interaction patterns familiar to Visual Studio Code users.

The explorer supports operations such as:

• Creating and managing files and folders.
• Inline file renaming.
• Context menus.
• Moving files to the trash.
• Organizing project structures.

These features help HydraCode function as a development environment rather than simply a code translation utility.

Extensible Language Mappings

HydraCode allows users to load language mappings from GitHub repositories.

This makes it possible to distribute and install additional human-language mappings without requiring users to modify the IDE’s source code.

Because externally supplied mappings introduce security and reliability concerns, the loader includes protections against issues such as regular-expression denial of service (ReDoS), language spoofing, oversized payloads, and race conditions.

The result is an extensibility model designed to support community contributions while accounting for the risks of loading external data.

Familiar Settings and Automatic Updates

HydraCode includes a VS Code-inspired settings panel, with user preferences persisted in userData/settings.json.

The application can also be packaged for Windows using Electron Builder and NSIS.

Automatic updates are handled through electron-updater, with GitHub Releases serving as the distribution mechanism.

Together, these features provide the foundation for distributing HydraCode as a standalone desktop application.

Technology Stack

HydraCode is built primarily with TypeScript and uses a collection of technologies commonly found in modern desktop development.

Component	Technology
Main language	TypeScript
Desktop runtime	Electron 42
Frontend tooling	Vite 6
Code editor	Monaco Editor
Visual programming	Blockly
Interactive terminal	xterm.js and node-pty
Speech recognition	Vosk
Syntax highlighting	TextMate grammars and Oniguruma
Testing	Vitest
Code quality	ESLint
Packaging	Electron Builder and NSIS
Automatic updates	electron-updater

The project’s source tree follows an architecture inspired by Visual Studio Code, with directories such as base, platform, workbench, and languages.

This structure separates core functionality from editor features and language-specific components, making the codebase easier to extend as the project grows.

The repository also includes TextMate grammar extensions for C++, Java, and Python to support syntax highlighting.

Development Challenges and Current Limitations

HydraCode is currently in the 0.1.0-pre-alpha.1 stage.

Although the project already includes a broad set of features, it remains experimental and has several known limitations.

For example, the IDE does not yet provide a full debugger. Installing a programming language currently enables syntax highlighting rather than automatically installing its compiler or runtime. Additionally, certain non-Latin Java class names may encounter execution issues on Windows.

These limitations are part of the project’s ongoing development process.

The repository’s CHANGES.md documents development sessions, bug investigations, security reviews, feature implementations, and known issues.

This development history reflects an iterative approach: implementing features, reviewing their behavior, identifying edge cases, and improving the system over time.

The Vision Behind HydraCode

HydraCode explores the possibility of making programming more accessible without sacrificing the capabilities of a traditional development environment.

Its central idea is simple: programming concepts should not become harder to learn simply because their syntax is written in another language.

By combining natural-language keywords with a real transpilation engine, an interactive terminal, visual programming, AI-assisted coding, and source control, HydraCode attempts to bridge the gap between beginner-friendly educational tools and practical software development.

Its architecture also opens the door to future experimentation with additional human languages, programming languages, and educational workflows.

Rather than treating native-language programming as a novelty, HydraCode approaches it as an extensible engineering problem.

Current development stage: 0.1.0-pre-alpha.1