eTamil

eTamil
Paradigm	Multi-paradigm: procedural (imperative), functional, structured
Designed by	Esan Maruff
Developer	Esan Maruff
First appeared	26 June 2024 (2024-06-26)
Stable release	1.1.0 / 23 September 2026 (2026-09-23)
Typing discipline	Dynamic, strong; optional declared types and record shapes checked before execution
OS	Windows, Linux, macOS, Android
License	AGPL-3.0-or-later
Filename extensions	.qmz
Website	etamil.in
Major implementations
etamil (reference implementation)
Influenced by
Rust, C++, Ezhil

eTamil is a high-level programming language whose keywords are words of the Tamil language. It is designed as a domain-specific language for Indian accounting, taxation and financial technology, and also provides the features of a general-purpose programming language, including first-class functions, user-defined record types, modules, database access and an HTTP server.

Financial concepts are part of the language's vocabulary rather than a library: வரவு (credit), பற்று (debit), வரி (tax) and இருப்புநிலை (balance sheet) are keywords. Every number is a fixed-point decimal, so that 0.1 + 0.2 evaluates to exactly 0.3. Each keyword may be written in Tamil script, in an ASCII romanization, or for most keywords with an English alias.

eTamil was created by Esan Maruff. It first appeared on GitHub in June 2024, and its current implementation dates from January 2026. Its reference implementation is written in Rust and includes a bytecode virtual machine and an experimental LLVM back end. Its standard library, nUlakam, is written in eTamil itself.

History

eTamil is the work of Esan Maruff (legal name Mohammed Maruff). It first appeared publicly on 26 June 2024 as eTml, a GitHub repository describing "an Indian DSL for Accounts & FinTech" with an early implementation in Rust. On 5 July 2024 it was followed by the eTamil repository, which held a prototype compiler, with a lexer, parser, semantic analyser and code generator, together with the project's website at etamil.in.

Maruff enrolled as a PhD scholar in the Department of Computer Applications at B. S. Abdur Rahman Crescent Institute of Science and Technology, Chennai, to document the language's approach, under the title "Developing an Indian DSL (Programming Language) for Accounts, Commerce, Finance, and Fintech Professionals". A paper of the same title was presented at the International Conference on Technology Enhanced Teaching and Learning (ICTETL 2025), held online on 23–24 October 2025 by the institute's Centre for Distance and Online Education in collaboration with Global College Malta, and published in the conference proceedings.

Over the following two years the language was developed in a series of separate repositories, each covering one part of the project or trying a different architecture. Among them were eTamil-ciRal, a framework of tools and libraries (August 2024); eTamil-nivaqi (September 2024); Accounts, an accounting module in Rust (February 2025); nivaqi-v1 (March 2025); and eTamil-Compiler, eTamil-vscode and eTamil_transpiler (January and February 2026). All were superseded by the current repository, first published on 26 January 2026 with a compiler and a Visual Studio Code extension providing syntax highlighting. Version 0.2 followed on 31 January 2026, adding documentation for the language's transliteration scheme. The original eTamil repository was not discarded, because it hosts the project's website; only its Rust compiler code was removed, in August 2026.

The language was substantially reworked in August 2026. Binary floating-point arithmetic was replaced throughout by fixed-point decimals, the financial and accounting vocabulary grew from 157 to 196 keywords, and functions, arrays, records, iteration, result types and modules were added, together with database access and an HTTP server.

Version 1.0.0 was released on 13 September 2026, with prebuilt packages for Windows, Linux and macOS and a Visual Studio Code extension that bundles the full toolchain. Versions 1.0.1 to 1.0.3 added a bundled typeface released under the SIL Open Font License. Version 1.1.0, released on 23 September 2026, added immutable bindings, first-class functions, record shapes and methods.

Major releases

Version	Release date	Principal changes
1.1.0	23 September 2026	Immutable bindings (நிலை), functions as values and closures, record shapes (வடிவம்) with methods; map, filter and fold in the standard library
1.0.0	13 September 2026	First stable release; database writes from compiled programs; installable packages for three operating systems
0.2	31 January 2026	Token corrections; transliteration documentation
—	26 January 2026	Current repository published: compiler and editor extension
—	5 July 2024	eTamil repository: prototype Rust compiler and website
—	26 June 2024	First public repository, eTml

Design philosophy and features

eTamil's design documents state that the language should let Tamil-speaking accountants and programmers express financial logic in their own language, without being a translation of an English-keyword language. The project describes several fixed principles:

• Exact money. Every value is a 28-digit fixed-point decimal and binary floating point is never used, so that a double-entry ledger balances exactly. Division keeps full precision and rounding is explicit, following the Indian tax practice of rounding once at the end of a computation.
• Loud failure. Unsupported constructs, undefined variables, division by zero and out-of-range indices raise errors rather than producing a default value. The project's rationale is that a silently wrong result from a tax calculation is worse than a crash, because a successful run is not investigated.
• Errors as values. Following Rust, operations that can fail return சரி (success) or தவறு (failure), propagated with a ? operator. The language has no exceptions.
• A thin host. Only what the language cannot express, such as system calls, database drivers and decimal and calendar primitives, is implemented in Rust. The standard library and the accounting framework are written in eTamil, which the project presents as evidence that the language is sufficient for the frameworks built on it.
• Names as written. An identifier is stored exactly as the programmer typed it, so a Tamil author's chosen names are never replaced by English equivalents.

Error messages are bilingual, in Tamil and English, and report a line and column. Columns count written Tamil letters rather than bytes.

Syntax and semantics

eTamil uses braces to delimit blocks and semicolons to end statements; these and much of the rest of its syntax were evaluated against C, C++ and Rust before being finalised, and a few keywords were adopted from Ezhil. Unlike most brace-delimited languages, eTamil places a condition before its keyword: (x > 0) எனில் { … } reads as "(x > 0) if { … }".

Keywords and scripts

The language has 203 keywords, accepted in 545 spellings in total. Each keyword has a Tamil-script form and a romanized form in the project's ezuqqu scheme, which maps each Tamil letter to ASCII characters so that programs can be typed on an ordinary keyboard. The scheme keeps the three Tamil nasal consonants distinct: ண is written N, ந n and ன Z. Most keywords also have an English alias beginning with an underscore, such as _if.

Selected keywords

Tamil	Romanized	Alias	Meaning
எனில்	eZil	_if	conditional
இன்றேல்	iZREl	_else	alternative branch
சுற்று	cuRRu	_loop	loop while a condition holds
ஒவ்வொரு … இல்	ovvoru … il	_each … _in	iteration over an array, record or string
செயல்	ceyal	_fn	function definition
திரும்பு	qirumpu	_return	return from a function
நிலை	nilY	_const	immutable binding
வடிவம்	vativam	_shape	record shape declaration
இறக்கு	iRakku	_import	import a module
அச்சு	accu	_print	print a value
மெய் / பொய் / இன்மை	mey / poy / iZmY	_true / _false / _null	Boolean and null literals

Type keywords and SQL clause keywords are reserved. Financial keywords are not, so தொகை (amount) may be used as a variable name. Because names are stored as typed, வருவாய் and its romanization varuvAy are different variables, although as keywords the two spellings are interchangeable.

Statements and control flow

eTamil's statements include:

• assignment with =, and the நிலை statement, which binds a name once; reassigning it or changing an element or field of its value is rejected before the program runs;
• the எனில் and இன்றேல் conditional statements;
• the சுற்று loop, which repeats while its condition holds, and the ஒவ்வொரு … இல் loop over arrays, records and strings;
• செயல் function definitions and the திரும்பு statement;
• இறக்கு, which imports a module, resolving the path beside the importing file and then along an ETAMIL_PATH environment variable;
• வழி, which declares an HTTP route, and பதில், which sends a response;
• இடைவெளி, which runs a block repeatedly at a fixed interval under the HTTP server.

Expressions

Arithmetic uses the usual infix operators. A number followed by % is a percentage, so 18% is the value 0.18. Strings are concatenated with &. The logical operators மற்றும் (and) and அல்லது (or) short-circuit, and இல்லை is logical negation. Comparisons chain, so a > b > c is equivalent to testing each neighbouring pair.

Arrays are written […] and records {…}. Arrays compare equal element by element and records field by field. A function written where a value is expected, செயல்(x) { திரும்பு x * 2; }, is an anonymous function; one created inside another function captures copies of the local variables it uses.

Typing

eTamil is dynamically typed, with optional type declarations that are enforced. A variable, parameter or return value may be declared as a number (எண்), string (சொல்) or function (செயல்). The checker is deliberately narrow and makes no claim about undeclared values, so that working programs are not rejected by guesses.

A வடிவம் declares a record shape: its fields and the type each holds. A record made as that shape must supply every field and no others. Errors that can be seen in the source are reported before execution; values known only at run time, such as database rows, are checked when the record is made. Functions declared inside a shape are its methods. A method whose first parameter is இது ("this") is called on a record and cannot modify it, comparable to Rust's &self; a changed record is a new value. There is no inheritance.

Arithmetic operations

All numbers are fixed-point decimals with up to 28 significant digits; the language has no separate integer or floating-point types. Equality between numbers is exact. Division retains full precision, and the built-in வட்டமிடு rounds to a given number of decimal places. When stored, money keeps its exactness: PostgreSQL columns use NUMERIC, MongoDB documents use Decimal128, and SQLite stores decimals as text.

Function syntax

A function is declared with செயல், a name, a parenthesised parameter list and a block. Parameters and the return value may carry declared types. Functions support recursion and local scope, and are values: they may be stored in variables, arrays and records, passed as arguments and returned.

Code examples

"Hello, World!" program:

அச்சு "வணக்கம், உலகம்!";

Exact decimal arithmetic, with the output of each line shown in a comment:

அச்சு 0.1 + 0.2;      // 0.3
அச்சு 99.99 * 3;      // 299.97
அச்சு 18%;            // 0.18

A conditional, reading an income and applying a tax rate above a threshold:

எண் வருவாய்;
அச்சு "வருமானம்: ";
உள்ளிடு வருவாய்;
வரி = 20%;

(வருவாய் > 800000) எனில் {
    அச்சு (வருவாய் - 800000) * வரி;
}
இன்றேல் {
    அச்சு "வரி இல்லை";
}

Error handling with result values; ? returns the failure to the caller:

செயல் வகு(மேல், கீழ்) {
    (கீழ் == 0) எனில் {
        திரும்பு தவறு("பூஜ்ஜியத்தால் வகுக்க முடியாது");
    }
    திரும்பு சரி(மேல் / கீழ்);
}

செயல் சராசரி_விலை(மொத்தம், எண்ணிக்கை) {
    ஒன்று = வகு(மொத்தம், எண்ணிக்கை)?;
    திரும்பு சரி(வட்டமிடு(ஒன்று, 2));
}

அச்சு சராசரி_விலை(1000, 3);   // சரி(333.33)
அச்சு சராசரி_விலை(1000, 0);   // தவறு(பூஜ்ஜியத்தால் வகுக்க முடியாது)

A record shape with a method computing a loan's equated monthly installment:

வடிவம் கடன் {
    எண் அசல்,
    எண் ஆண்டு_வீதம்,
    எண் மாதங்கள்,

    செயல் தவணை(இது) எண் {
        ம = இது.ஆண்டு_வீதம் / 12;
        காரணி = 1;
        எண்ணி = 0;
        (எண்ணி < இது.மாதங்கள்) சுற்று {
            காரணி = காரணி * (1 + ம);
            எண்ணி = எண்ணி + 1;
        }
        திரும்பு வட்டமிடு(இது.அசல் * ம * காரணி / (காரணி - 1), 2);
    }
}

நிலை வீட்டுக்_கடன் = கடன்{அசல்: 500000, ஆண்டு_வீதம்: 9%, மாதங்கள்: 60};
அச்சு "மாதத் தவணை: " & வீட்டுக்_கடன்.தவணை();   // மாதத் தவணை: 10379.18

Iteration over an array of records, using the standard library's rupee formatting with Indian digit grouping:

இறக்கு "nUlakam/paNam.qmz";

செலவுகள் = [
    {"பெயர்": "வாடகை", "தொகை": 18000},
    {"பெயர்": "மின்சாரம்", "தொகை": 2450.50}
];

மொத்தம் = 0;
ஒவ்வொரு பதிவு இல் செலவுகள் {
    அச்சு பதிவு.பெயர் & ": " & ரூபாய்(பதிவு.தொகை);
    மொத்தம் = மொத்தம் + பதிவு.தொகை;
}
அச்சு "மொத்தம்: " & ரூபாய்(மொத்தம்);   // மொத்தம்: ₹20,450.50

An HTTP route returning JSON:

வழி பெறு, "/api/hello" {
    ஜேசான்_உரை "{\"message\": \"Hello, World!\"}", 200;
}

வழங்கி_தொடங்கு "localhost", 8080;

Libraries

eTamil's standard library, nUlakam (from நூலகம், "library"), is written in eTamil rather than in the host language. Its general-purpose modules cover strings, mathematics, arrays, records, dates and working-day calendars, JSON, Base64 and hexadecimal encoding, document templating, and a unit-testing framework whose failures produce a non-zero exit status for use in continuous integration.

Its domain modules include:

• Accounting – a chart of accounts, journal and ledger with a balance check, Goods and Services Tax entries, accounting periods, multi-entity and foreign-currency handling, period close, and the trial balance, income statement, balance sheet and cash flow statement.
• Depreciation, payroll and tax – straight-line and written-down-value depreciation, payroll, and a marginal slab engine for income tax and professional tax. Rates are held in an effective-dated table that is queried by date; the library ships with no rates.
• Cost accounting – cost sheets, overhead absorption, standard costing variances, cost–volume–profit analysis, process costing and activity-based costing.
• Revenue recognition – the five steps of Ind AS 115, the Indian counterpart of IFRS 15.
• Project control – work breakdown structures, earned value, the critical path, risk registers and three-point estimation.
• Banking, insurance and customs – simple and compound interest, loan installments, asset classification, insurance claim settlement including the average clause, and the customs duty cascade.
• Payments and ledgers – Unified Payments Interface address validation, payment links and a payment state machine, and a client for Hyperledger Fabric.

The runtime also provides database drivers for SQLite, PostgreSQL, MySQL and MariaDB, MongoDB and Redis, in which queries are always parameterised; outbound HTTP; HMAC-SHA256, ECDSA P-256, bcrypt and JSON Web Token support; mutual TLS; and reading and writing OpenDocument and Office Open XML files.

Development environments

The reference implementation includes an interactive read–eval–print loop, started with --repl. A Visual Studio Code extension provides syntax highlighting for every keyword spelling, completions for the built-in and standard-library functions, and diagnostics as the programmer types; it bundles the compiler, standard library, examples and the eTamil typeface, so that installing it installs the language. The extension's grammar is generated from the compiler's lexer.

Grammars are also maintained for tree-sitter, Pygments, Rouge and highlight.js. The project's website hosts an in-browser editor built on a WebAssembly build of the compiler, and a bilingual user manual in English and Tamil.

Implementations

Reference implementation

The reference implementation, etamil, is a single Rust crate. Source text is tokenised by a lexer generated with the logos library, parsed into an abstract syntax tree and checked, then executed by one of two back ends. The primary back end compiles to bytecode for a virtual machine, which runs every feature of the language and also serves as the HTTP server, using either a thread pool or an asynchronous accept loop built on the Tokio library. The second back end emits LLVM intermediate representation on Linux and macOS.

Prebuilt packages are published for Windows (x86-64), Linux (x86-64, as a statically linked musl binary) and macOS (x86-64 and Apple silicon); installation does not require administrator rights.

Limitations of the reference implementation

The LLVM back end represents every value as a handle into a run-time arena and calls into the same Rust library for each operation. This keeps its decimal results identical to the virtual machine's, but compiled programs must link that library, and statements performing file, database or HTTP operations are not yet supported by it. The virtual machine itself is synchronous and has no user-level threads. A program can hold only one database connection at a time, and there is no language-level transaction construct.

Other implementations

An Android application embeds the reference compiler, cross-compiled and loaded through the Java Native Interface, and runs the complete language including the virtual machine, SQLite and the HTTP client. The in-browser editor uses a WebAssembly build of the compiler's front end.

Performance

In measurements published by the project in September 2026, an eTamil HTTP server used about 3.5 MB of resident memory, and four demonstration backends together used 14 MB, on a virtual server with 4 GB of memory and two virtual CPUs.

Language development

eTamil is developed in the open on GitHub under the AGPL-3.0-or-later licence. Its roadmap divides the work into five phases taken from the language's design paper; as of September 2026 the compiler and core language were described as substantially complete, and the open-source release had been made, but no pilot deployment against a production system had taken place. Continuous integration runs on two operating systems, and checks that the editor grammars and published keyword counts match the compiler.

The project maintains a narrow layering rule: a capability is implemented in the Rust host only when it cannot be expressed in eTamil. Rounding, which needs the decimal representation, is built in; Indian digit grouping, which is string manipulation, is written in eTamil.

Naming

Standard-library modules are named with romanized Tamil words, such as paNam.qmz (பணம், "money") and kaNakkiyal (கணக்கியல், "accounting").

See also

• Ezhil (programming language) – a Tamil-keyword language aimed at education
• Non-English-based programming languages
• COBOL – a language designed around business data processing
• Decimal data type

External links

• Official website
• eTamil on GitHub
• User manual in Tamil