# nishok-12/aram architecture

> Architecture diagram of the GitHub repository nishok-12/aram, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-08-14). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/nishok-12/aram
- Repository: https://github.com/nishok-12/aram

## Overview

#### Purpose and Entry Point
Aram is a Python implementation of a Tamil-syntax programming language, including its lexer, parser, interpreter, built-in library, and desktop IDE. The intended current entry point is `Main_code/ARAM(GUI_Version_8.2).py`; a packaged Windows executable is also present at `Main_code/Aram.exe`.

#### Desktop IDE Layer
The GUI is the user-facing boundary: it accepts source code, initiates language processing, and presents execution output or errors. The project retains an evolutionary sequence of IDE implementations, rather than a single stable GUI module.
- `Main_code/ARAM(GUI_Version_8.2).py`
- `Main_code/ARAM(GUI_Version_7.3).py`
- `Main_code/ARAM(GUI_Version_1).py`

The material GUI runtime is Python with Tkinter/GUI components, not a web stack.

#### Language Front End: Lexing
Raw Aram source text first crosses into the compiler/interpreter pipeline through lexical analysis. The lexer recognizes the language’s Tamil-oriented syntax and produces tokens for parsing.
- `Main_code/AramLexer.py`

This is the boundary between free-form editor text and structured language input.

#### Language Front End: Parsing
The parser consumes lexer tokens and constructs a structured program representation/abstract syntax tree suitable for execution. It is the syntax-validation and program-shaping stage between tokenization and evaluation.
- `Main_code/AramParser.py`

Primary control flow is: GUI or import caller → lexer → parser → interpreter.

#### Execution Engine
The interpreter executes parsed Aram program logic. It is the central runtime boundary where language structures, values, control flow, and user programs are evaluated.
- `Main_code/AramInterpreter.py`
- `Main_code/AramImport.py`

`AramImport.py` likely supports program/module loading across the language runtime, separating imported-source handling from direct execution.

#### Runtime Services and Shared State
Language-visible standard operations are supplied separately from core evaluation by the built-in library. Shared runtime state and common reporting are centralized rather than duplicated across pipeline stages.
- `Main_code/AramBuiltIns.py`
- `Main_code/globals.py`
- `Main_code/error.py`

`AramBuiltIns.py` is the extension boundary for standard-library behavior; `globals.py` is the shared-state boundary; `error.py` provides centralized error representation/reporting used by language processing and the GUI.

#### Distribution and Versioning
The repository is source-first Python, with a Windows executable distribution artifact and a version record.
- `Main_code/Aram.exe`
- `Main_code/Versions.txt`

There are no indicated cloud services, databases, network APIs, or server infrastructure. Execution is local: a desktop GUI drives an in-process Python interpreter pipeline.

Main entry points: [`Main_code/AramInterpreter.py`](https://github.com/nishok-12/aram/blob/main/Main_code/AramInterpreter.py) (Aram Interpreter), [`Main_code/AramLexer.py`](https://github.com/nishok-12/aram/blob/main/Main_code/AramLexer.py) (Aram Lexer), [`Main_code/ARAM(GUI_Version_8.2).py`](https://github.com/nishok-12/aram/blob/main/Main_code/ARAM(GUI_Version_8.2).py) (GUI v8.2), [`Main_code/error.py`](https://github.com/nishok-12/aram/blob/main/Main_code/error.py) (Error Reporting)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_ide["Desktop IDE"]
  node_gui_current["GUI v8.2<br/>Tkinter IDE"]
  node_gui_legacy["Legacy GUIs<br/>Tkinter IDE versions"]
end

subgraph group_frontend["Language Front End"]
  node_lexer["Aram Lexer<br/>[AramLexer.py]"]
  node_parser["Aram Parser<br/>[AramParser.py]"]
end

subgraph group_runtime["Runtime Services"]
  node_interpreter{{"Aram Interpreter<br/>execution engine<br/>[AramInterpreter.py]"}}
  node_importer["Import Runtime<br/>module loader<br/>[AramImport.py]"]
  node_builtins["Built-in Library<br/>standard library<br/>[AramBuiltIns.py]"]
  node_shared_state["Shared State<br/>runtime state<br/>[globals.py]"]
  node_errors["Error Reporting<br/>error service<br/>[error.py]"]
end

subgraph group_distribution["Distribution"]
  node_windows_exe["Aram.exe<br/>Windows executable<br/>[Aram.exe]"]
  node_versions["Version Record<br/>version metadata<br/>[Versions.txt]"]
end

node_gui_current -->|"source text"| node_lexer
node_lexer -->|"tokens"| node_parser
node_parser -->|"program representation"| node_interpreter
node_interpreter -->|"loads imports"| node_importer
node_importer -->|"imported source"| node_lexer
node_interpreter -->|"standard operations"| node_builtins
node_interpreter -->|"reads and updates"| node_shared_state
node_lexer -->|"reports failures"| node_errors
node_parser -->|"reports failures"| node_errors
node_interpreter -->|"reports failures"| node_errors
node_errors -->|"displays errors"| node_gui_current
node_interpreter -->|"execution output"| node_gui_current
node_windows_exe -.->|"packages entry point"| node_gui_current
node_versions -.->|"release version"| node_windows_exe

click node_gui_current "https://github.com/nishok-12/aram/blob/main/Main_code/ARAM(GUI_Version_8.2).py"
click node_gui_legacy "https://github.com/nishok-12/aram/blob/main/Main_code/ARAM(GUI_Version_7.3).py"
click node_lexer "https://github.com/nishok-12/aram/blob/main/Main_code/AramLexer.py"
click node_parser "https://github.com/nishok-12/aram/blob/main/Main_code/AramParser.py"
click node_interpreter "https://github.com/nishok-12/aram/blob/main/Main_code/AramInterpreter.py"
click node_importer "https://github.com/nishok-12/aram/blob/main/Main_code/AramImport.py"
click node_builtins "https://github.com/nishok-12/aram/blob/main/Main_code/AramBuiltIns.py"
click node_shared_state "https://github.com/nishok-12/aram/blob/main/Main_code/globals.py"
click node_errors "https://github.com/nishok-12/aram/blob/main/Main_code/error.py"
click node_windows_exe "https://github.com/nishok-12/aram/blob/main/Main_code/Aram.exe"
click node_versions "https://github.com/nishok-12/aram/blob/main/Main_code/Versions.txt"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_gui_current,node_gui_legacy toneBlue
class node_lexer,node_parser toneAmber
class node_interpreter,node_importer,node_builtins,node_shared_state,node_errors toneMint
class node_windows_exe,node_versions toneRose
```

## Components

### Desktop IDE

- [GUI v8.2](https://github.com/nishok-12/aram/blob/main/Main_code/ARAM(GUI_Version_8.2).py): Tkinter IDE · Current desktop entry point for editing and running Aram code. · `Main_code/ARAM(GUI_Version_8.2).py`
- [Legacy GUIs](https://github.com/nishok-12/aram/blob/main/Main_code/ARAM(GUI_Version_7.3).py): Tkinter IDE versions · Retained earlier IDE implementations. · `Main_code/ARAM(GUI_Version_7.3).py`

### Language Front End

- [Aram Lexer](https://github.com/nishok-12/aram/blob/main/Main_code/AramLexer.py): lexer · Turns Tamil-syntax source text into tokens. · `Main_code/AramLexer.py`
- [Aram Parser](https://github.com/nishok-12/aram/blob/main/Main_code/AramParser.py): parser · Validates token structure and builds the program representation. · `Main_code/AramParser.py`

### Runtime Services

- [Aram Interpreter](https://github.com/nishok-12/aram/blob/main/Main_code/AramInterpreter.py): execution engine · Evaluates parsed programs, values, and control flow. · `Main_code/AramInterpreter.py`
- [Import Runtime](https://github.com/nishok-12/aram/blob/main/Main_code/AramImport.py): module loader · Loads imported Aram program sources. · `Main_code/AramImport.py`
- [Built-in Library](https://github.com/nishok-12/aram/blob/main/Main_code/AramBuiltIns.py): standard library · Provides language-visible standard operations. · `Main_code/AramBuiltIns.py`
- [Shared State](https://github.com/nishok-12/aram/blob/main/Main_code/globals.py): runtime state · Centralized shared runtime state. · `Main_code/globals.py`
- [Error Reporting](https://github.com/nishok-12/aram/blob/main/Main_code/error.py): error service · Central error representation and reporting. · `Main_code/error.py`

### Distribution

- [Aram.exe](https://github.com/nishok-12/aram/blob/main/Main_code/Aram.exe): Windows executable · Packaged Windows distribution artifact. · `Main_code/Aram.exe`
- [Version Record](https://github.com/nishok-12/aram/blob/main/Main_code/Versions.txt): version metadata · `Main_code/Versions.txt`

## Connections

- GUI v8.2 → Aram Lexer: source text
- Aram Lexer → Aram Parser: tokens
- Aram Parser → Aram Interpreter: program representation
- Aram Interpreter → Import Runtime: loads imports
- Import Runtime → Aram Lexer: imported source
- Aram Interpreter → Built-in Library: standard operations
- Aram Interpreter → Shared State: reads and updates
- Aram Lexer → Error Reporting: reports failures
- Aram Parser → Error Reporting: reports failures
- Aram Interpreter → Error Reporting: reports failures
- Error Reporting → GUI v8.2: displays errors
- Aram Interpreter → GUI v8.2: execution output
- Aram.exe → GUI v8.2: packages entry point
- Version Record → Aram.exe: release version