Intelligent Natural Language Programming System: GEN - AN AI Powered Compiler for Translating English Instructions into Executable Code

Abstract

Natural language programming has emerged as a promising paradigm for reducing the complexity of software development and making computational systems more accessible to non-expert users. Traditional programming languages require users to learn complex syntax and semantics, which often act as significant barriers for beginners. To address these challenges, this paper presents the design and development of an intelligent Natural Language Programming Environment (NLPE) that enables users to write instructions in English and automatically converts them into executable code. The proposed system integrates Natural Language Processing (NLP) techniques with Large Language Models (LLMs) to translate human language into a structured domain-specific programming language. An LLM-based parser, implemented using Ollama (LLaMA 3) and guided by prompt engineering and fewshot learning, ensures accurate and consistent code generation. A rule-based interpreter, developed using Flask, executes the generated code in real time, supporting essential programming constructs such as variables, arithmetic operations, conditional statements, loops, and function definitions. Unlike conventional AI-assisted coding tools that primarily focus on code generation, the proposed framework emphasizes controlled execution and deterministic behavior by separating language understanding from execution logic. This design improves reliability, reduces ambiguity, and enhances user trust in generated outputs. Experimental evaluation demonstrates high accuracy for structured natural language inputs, consistent execution performance, and responsiveness suitable for interactive environments.

Introduction

1. This paper presents an Intelligent Natural Language Programming System that enables users to write programs using plain English instead of traditional programming syntax. The system addresses the difficulty beginners face when learning programming languages, where strict syntax rules and grammar often lead to errors and a steep learning curve.

   Recent advances in Artificial Intelligence (AI) and Large Language Models (LLMs) have made it possible to convert human language into executable code. However, existing AI coding assistants mainly generate code and often lack controlled execution environments, resulting in unpredictable behavior and requiring manual debugging. To overcome these limitations, the proposed system combines LLM-based code generation with a custom interpreter that executes code in a deterministic and reliable manner.

   Objectives

   The system aims to:

2. Enable programming through natural language.
3. Reduce the complexity of programming syntax.
4. Provide real-time code execution.
5. Build a scalable AI-driven programming environment.

6. Proposed Architecture

   The system follows a modular pipeline:

   User Input → LLM Parser → Custom DSL Code → Interpreter → Output

   The architecture consists of four main modules:

7. Natural Language Parser
8. Code Generator
9. Execution Engine (Interpreter)
10. User Interface

11. Methodology

    1. Input Processing

    Users enter English instructions through a web interface. The system preprocesses the input by:

12. Removing unnecessary spaces.
13. Normalizing text.
14. Validating input format.

15. 2. Natural Language to Code Translation

    An LLM (implemented using Ollama with LLaMA 3) converts English instructions into a custom Domain-Specific Language (DSL).

    Key techniques include:

16. Prompt Engineering: Uses strict syntax rules and examples to guide code generation.
17. Few-Shot Learning: Provides sample translations to improve accuracy and consistency.
18. Produces structured DSL commands instead of raw programming code.

19. Example:

20. "Add 5 and 3" → add 5 3
21. "Show hello" → show "hello"

22. 3. Code Interpretation and Execution

    A custom interpreter executes DSL commands using a rule-based approach.

    Supported features:

23. Variables and assignments
24. Arithmetic operations
25. Conditional statements
26. Loops
27. Functions
28. Input and output operations

29. The interpreter maintains:

30. Memory state (variables)
31. Function definitions
32. Execution history

33. Function

    define greet
    show "Hello"
    end
    
    call greet

    Interpreter Design

    The interpreter is the core execution engine and focuses on:

34. Simplicity: Easy-to-parse instructions.
35. Determinism: Predictable results for identical inputs.
36. Efficiency: Low computational overhead.
37. Extensibility: Easy addition of new language features.
38. Robustness: Graceful handling of runtime errors.

39. Key components include:

40. Memory management
41. Function storage
42. Execution control
43. Tokenization and parsing
44. Error handling

45. Error Handling

    The system safely handles:

46. Invalid syntax
47. Undefined variables
48. Division by zero
49. Runtime exceptions

50. This prevents crashes and improves reliability.

    Frontend Interface

    The user interface is developed using:

51. HTML
52. CSS
53. JavaScript
54. CodeMirror Editor

55. Features include:

56. Natural language input area
57. Generated DSL code display
58. Real-time execution results
59. Syntax highlighting and editing support

60. Advantages of the Proposed System

61. Eliminates the need to learn complex programming syntax.
62. Converts natural language directly into executable programs.
63. Provides a controlled and predictable execution environment.
64. Supports essential programming concepts.
65. Offers immediate feedback through a web interface.
66. Easily scalable for future language and feature extensions.

67. 4. Output Generation

    Execution results are displayed immediately through the web interface, providing real-time feedback to users.

    Custom Domain-Specific Language (DSL)

    The DSL is designed to be simple and easy to execute.

    Examples:

    Output

    show "Hello"

    Variable Assignment

    x = 10

    Conditional

    if x is greater than 5
    show "Big"
    end

    Loop

    repeat 3 times
    show "Hello"
    end

Conclusion

This paper presented an intelligent Natural Language Programming System that bridges the gap between human language and machine-executable code. By integrating a Large Language Model (LLM)-based parser with a custom-designed interpreter, the system enables users to write instructions in natural language and execute them in real time. The proposed framework demonstrates that natural language can serve as an effective programming interface, significantly reducing the learning curve for beginners. The use of a domain-specific language ensures structured and deterministic execution, while the web-based interface provides an interactive and userfriendly environment. Experimental results indicate high translation and execution accuracy for structured inputs, along with efficient system performance. The modular architecture of the system allows for easy extensibility and future enhancements. Despite certain limitations, the system highlights the potential of combining AI-driven language understanding with controlled execution environments. This approach opens new possibilities for educational tools, AI-assisted development systems, and human-centered programming interfaces. With further improvements in model accuracy, security, and feature support, the proposed system can evolve into a comprehensive platform for next-generation intelligent programming.

References

[1] OpenAI, Large Language Models, 2024. [2] Meta AI, LLaMA 3, 2025. [3] Flask Documentation, 2025. [4] CodeMirror Editor, 2024.

Copyright

Copyright © 2026 Nani Gedela, Mr. M. Chiranjeevi, Amulya Devarapalli, Madhu Motani, Varsha Sudha Munagapati. This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.