A paradigm

Natural, and executable

A sentence in your language runs, with no AI model, because every word of it is in a dictionary the library owns. What the library does not know, it refuses, and says why.

One program, three languages

The idea is the oldest in Softanza: that the thinking can be written as a sentence and the sentence can run. Here is a program as an English paragraph, run as it stands. A word outside the dictionary is not guessed at; the library reads the words it owns and acts on them.

A program written as English sentences, run as it stands: no model reads it, the library's dictionary does.

Softanza

Naturally("
    Make a string with 'hello niger' inside
    Spacify it and uppercase it
    @Box it while the box@ is rounded
    Display it on the screen
    Thank you very much
")

Output

╭───────────────────────╮
│ H E L L O   N I G E R │
╰───────────────────────╯

run on 2026-10-08 21:47 inside the library at commit 4a184e6f0; taken from base/test/natural/32_natural_code_in_english.ring(opens in a new tab)

The same program in Hausa: the words differ, the meanings are the same entries of one dictionary.

Softanza

o1 = NaturallyIn("hausa", "
    Yi rubutu da dauke 'hello niger' a ciki
    Raba shi kuma maida shi
    @Akwati shi kuma wannan akwati@ dole zagaye
    Nuna shi a kan allo
    Na gode susai
")

Output

╭───────────────────────╮
│ H E L L O   N I G E R │
╰───────────────────────╯

run on 2026-10-08 21:47 inside the library at commit 4a184e6f0; taken from base/test/natural/33_natural_code_in_hausa_latin_script_boko.ring(opens in a new tab)

French, Arabic and Turkish, verb last: each sentence runs, and each says back, in its own language, what it understood.

Softanza

o1 = NaturallyIn("fr", "Crée une liste avec [ 5, 3, 5, 1 ] et enlève les doublons")
? @@( o1.Result() )
? o1.Understood()

o2 = NaturallyIn("ar", "أنشئ قائمة بـ [ 5, 3, 5 ] ثم أزل تكراراتها")
? @@( o2.Result() )
? o2.Understood()

o3 = NaturallyIn("tr", "[ 3, 1, 3 ] ile bir liste oluştur ve tekrarları kaldır")
? @@( o3.Result() )

Output

[ 5, 3, 1 ]
crée liste avec [ 5, 3, 5, 1 ] -> enlève les doublons
[ 5, 3 ]
أنشئ قائمة بـ [ 5, 3, 5 ] -> أزل التكرارات
[ 3, 1 ]

run on 2026-10-08 21:47 inside the library at commit 4a184e6f0; taken from base/test/natural/multilingual_pack_narrated.ring(opens in a new tab)

The Hausa program has different words and the same meaning: every language is a set of words keyed to the same entries of one dictionary, so a sentence in any of them lands on the same operation. The French and Arabic sentences do not translate English word for word, they follow their own grammar, and the Turkish one puts its verb last. Each program says back, in its own language, what it understood.

Who parses

There are two directions, and the difference is who does the reading.

The machine parses

Naturally() takes a paragraph. The library reads it against its dictionary and must refuse what it cannot prove it understood. Ambiguity is refused loudly. The audience is domain experts and AI agents.

The programmer parses

A near-natural chain is code that reads as a sentence. The human is the parser, and the chain is the sentence: a chain that runs but does not read as grammatical English is a bug. The audience is programmers.

The other direction: a chain that reads as an English sentence, where the programmer is the parser; a number asked for its vowels is refused.

Softanza

# the other direction: the programmer is the parser, the chain is the sentence
? TheWordQ("niger").IsAQ([ :Lowercase, :Latin, :Word ]).WithQ().
	ALengthQ().OfQ(5).UnitQ(:Letters).AndQ().OnlyQ(2).VowelNB()

# a sentence that makes no sense is refused, not absorbed
bRefused = 0
try
    Q(5).VowelNB()
catch
    bRefused = 1
done
? bRefused

Output

1
1

run on 2026-10-08 21:47 inside the library at commit 4a184e6f0; taken from base/test/natural/nnl_narrated.ring(opens in a new tab)

What it does not know, it refuses

A system that answers anything is a system you cannot trust with the answer. The natural layer is a closed language: a word it does not know is a literal and never a guess, a misspelled word is named together with the nearest word it does know, and a template with a hole left empty refuses to run.

What it does not understand, it says: the misspelled word is named with the nearest word the dictionary holds, and an unknown word resolves to nothing.

Softanza

aLint = StzNaturalLintIn("fr", "Crée une chaine avec 'x' et majuscul la")
# understood entirely? no
? aLint[:understood]
# the word it does not know, and the nearest word it knows
? @@( aLint[:unresolved] )
# a word outside the dictionary means nothing, never a guess
? StzResolveSemanticInLang("fr", "zzqx") = ""

Output

0
[ [ "majuscul", "majuscule" ] ]
1

run on 2026-10-08 21:47 inside the library at commit 4a184e6f0; taken from base/test/natural/multilingual_pack_narrated.ring(opens in a new tab)

One sentence with holes, many programs; and a hole left unfilled refuses to run instead of guessing.

Softanza

cTmpl = "Create a list with {#1} and remove its duplicates"
? @@( NaturallyWith(cTmpl, [ [ 5, 3, 5 ] ]).Result() )
? @@( NaturallyWith(cTmpl, [ [ 9, 9, 4 ] ]).Result() )

# a hole left empty is refused: a template is a contract
bRefused = 0
try
    NaturallyWith("Create a string with {#1} and {#2} it", [ "x" ])
catch
    bRefused = 1
done
? bRefused

Output

[ 5, 3 ]
[ 9, 4 ]
1

run on 2026-10-08 21:47 inside the library at commit 4a184e6f0; taken from base/test/natural/literate_templates_narrated.ring(opens in a new tab)

The Softanza way A sentence in your language runs because every word of it is admitted, and the refusal comes with its reason. The naturalness is at the door; the execution happens in a closed language that can be judged.

Languages are data

A language pack is a block of data keyed to the same meanings as English. Five packs ship: English, Hausa in Latin script, French, Arabic and Turkish. Adding one needs no code and no load.

A language added while the program runs, as a block of data: no code, no load, and its first sentence runs.

Softanza

StzAddNaturalLanguage([
	:code = "sw",
	:name = "swahili",
	:script = "latin",
	:ignored_words = [ "na", "ya", "kwa", "hii" ],
	:semantic_mappings = [
		[:natural = "unda",   :semantic = "CREATE_OBJECT"],
		[:natural = "orodha", :semantic = "OBJECT_LIST"],
		[:natural = "na",     :semantic = "VALUE_INDICATOR"]
	],
	:phrases = [
		[:semantic = "METHOD_REMOVEDUPLICATES", :words = "ondoa nakala, futa nakala"]
	]
])
? StzHasLanguagePack("sw")
? @@( NaturallyIn("sw", "Unda orodha na [ 9, 4, 9 ] ondoa nakala").Result() )

Output

1
[ 9, 4 ]

run on 2026-10-08 21:47 inside the library at commit 4a184e6f0; taken from base/test/natural/multilingual_pack_narrated.ring(opens in a new tab)

Hausa in Ajami script is named in the library and not shipped; Zarma and Fulfulde are not there yet. They are the next packs to write, and a pack is data.

Five faces

Determinism and sovereignty

The natural layer calls no AI model and needs no key, and the same sentence gives the same answer on any day. That is the condition for a bank or a ministry, not a feature. That no network connection opens during a natural run is not yet measured by a guard of its own.

Accountability

Every sentence can say what it understood, what it refused, and why. That is what separates this from code generated by an AI model and from a language of fixed commands.

Languages as data

A language is a block, added at runtime. A speaker of Hausa or Arabic writes to the same library as a speaker of English.

Two directions, one discipline

The machine that parses and the human who parses share one lexicon: the grammar of the function forms, read as a vocabulary.

The agent's door (designed)

An AI model may draft; a closed grammar judges. Holding an AI model to the lexicon's grammar, so that it can only produce sentences the layer executes, is designed and not built.

Where it comes from

2020. The first slide of the first deck gives the rationale as "expressing the thinking in an executable natural language".
The turn. The author's article on why the natural layer was built states the thesis: a sentence is modelled as code, with no language processing and no machine learning, at native speed, deterministic, with the programmer in control.
The three eras. The layer was built in three stages, each against one wall: the gap between a person's intention and its execution.
2026-07-10. The library's own review found that of fifteen canonical examples run as written, four ran as the articles said. The surface had decayed because no test had ever locked it. It was renovated that day and is held by scenario guards since.

The three articles that tell it are published here with their code run: stzNatural, stzNatural against the older natural library and near-natural language programming. Several of their blocks no longer run as written, and their pages say which.

Limits

in construction The vocabulary is bounded by the packs, and each pack covers a part of what the library can do. A program is one object per block. Ambiguity is refused and not resolved. The surface decayed once and is guarded now, which is a promise about the future and not about the past. The article blocks that do not run as written are not yet pinned as examples.

Sources: the scenario guards multilingual_pack_narrated.ring(opens in a new tab), nnl_narrated.ring(opens in a new tab) and literate_templates_narrated.ring(opens in a new tab); the code of the layer is in base/natural(opens in a new tab).