txlyre's website

Welcome to my personal website!

This website is a place for both most of my projects, as well as ways to contact me.
satyurein síva! lúrá anyélasély télmen ûsí pélisea âmener ámë.

P.S. txlyre is pronounced /təkslɪr/IPA.

Contacts

Ugushian language / Ùgùcsë mòwa / Ўугўушӓ мова - a constructed language

A constructed South Slavic language inspired by Czech, Croatian and Russian languages.




Phonology

A a / А а - [a]
à ã / А̃ а̃ - [ã]
À à / Э̃ э̃ - [ɛ̃]
Á á / Є є - [æː]
B b / Б б - [b]
C c / Ц ц - [ts]
D d / Д д - [d]
E e / Э э - [ɛ]
È è / Е е - [e]
Ę ę / Ы ы - [ɨ], [jɨ] at end of the word
Ë ë / Ӓ ӓ - [ə]
F f / Ф ф - [f]
G g / Г г - [g]
H h / Х х - [x], written as 'ch' at end of the word
I i / И и - [i], /ʲi/ after consonants
Í í / I i - [y̆]
J j / J j - [j]
K k / К к - [k]
L l / Л л - [l]
Ł ł / Ў ў - [w]
M m / М м - [m]
N n / Н н - [n]
Ñ ñ / Ӈ ӈ - [ŋ]
O o / О̆ о̆ - [ɔ]
Ò ò / О о - [o]
Ó ó / Ўэ ўэ - [wɛ]
Õ õ / О̃ о̃ - [õ]
Ô ô / Ўï ўï - [ɞ]
Ö ö / Ё ё - [ɵ]
P p / П п - [p]
R r / Р р - [r]
S s / С с - [s]
T t / Т т - [t]
U u / У у - [u]
Ù ù / Ўу ўу - [wʉ]
W w / В в - [v]
Y y / Ï ï - [ɪ]
Z z / З з - [z]
Ż ż / Ж ж - [ʒ]
Cs cs / Ш ш - [ɕ]
Zc zc / Щ щ - [ɕʲ]
Tz tz / Ӵ ӵ - [t͡ʃ]
Rz rz / Ҏ ҏ - [rʒ]
Cz cz / Ч ч - [t͡ɕ]

Samples

Jó zbutilm cò be w ni ksàżkie / Jўэ збутилм цо бэ в ни ксэ̃жкиэ - I forgot what was in that book.
Gdiè á mòj pisjac? / Гдие є моj писjац? - Where is my pencil?
Jó imëm maczkã, ktòrna wòlity rybã / Jўэ имӓм мачка̃, кторна волитï рïба̃ - I have a cat, that loves fish.

Vocabulary

pisën - verb - to write
csë - verb - to live; to inhabit
môże - verb - to be able to
ùme - verb - to "can"
widza - verb - to see
mrzè - verb - to hate
spièwë - verb - to sing
imë - verb - to have
grët - verb - to speak
cstipàt - verb - to split
nátz - verb - to find
pcstòwë - verb - to put
zmrët - verb - to die
bècsèli - verb - to talk; to chat
priji - verb - to come
itzi - verb - to walk; to go
izli - verb - to go out
ùhrãst - verb - to steal
rëstiż - verb - to grow
òtprëw - verb - to send
slucz - verb - to hear
ùzet - verb - to take
tcsyt - verb - to bring
krit - verb - to scream
czkati - verb - to wait
dati - verb - to give
utròcsë - verb - to use
zmëcsl - verb - to think
sjèt - verb - to remember
hlùkes - verb - to noise
dęch - verb - to breathe
wòli - verb - to like; to love
uczi - verb - to learn
sjëdti - verb - to sit
lèżat - verb - to lie
wèdë - verb - to know
dòcsti - verb - to rain
zbuti - verb - to forget
bast - verb - to throw
jest - verb - to eat
wihr - verb - to win
zdrzet - verb - to contain; to refrain
zwjëti - verb - to contact; to connect
pasti - verb - to fall
wrzùmèt - verb - to understand
ùlębcsi - verb - to smile
mry - verb - must; shall; to have to
ancsë - verb - to eat
zbtròwi - verb - to make; to create
statcë - verb - to happen
zprczèwti - verb - to deny
drògi - noun F. - road
ksàżk - noun F. - book
maczk - noun F. - cat
pijèsm - noun F. - song
kupus - noun F. - cabbage
mòw - noun F. - language
drèw - noun F. - tree
èd - noun F. - food
podiar - noun F. - spring
żen - noun F. - woman
dèkl - noub F. - girl
cstr - noun F. - sister
vòjn - noun F. - war
pônw - noun F. - country
mãt - noun F. - mother
ryb - noun F. - fish
wod - noun F. - water
këst - noun F. - bone
sjal - noun F. - star
kùkrz - noun F. - corn
símj - noun F. - family
òznk - noun F. - feature
drw - noun N. - tree
rzic - noun N. - word
wrmj - noub N. - time
dżàt - noun N. - stick
niòm - noun N. - name
wlèczin - noun N. - most
ckl - noun N. - glass
mstècz - noun N. - city
klùtzèn - noun N. - adventure
durcs - noun N. - stupidity
zrazk - noun M. - example
głísn - noun M. - vowel
zglísn - noun M. - consonant
prjèkt - noun M. - project
pisjac - noun M. - pencil
czèhl - noun M. - human; person
snich - noun M. - snow
otièc - noun M. - father
brac - noun M. - brother
dòm - noun M. - house; home
csel - noun M. - wind
dòcst - noun M. - rain
kòt - noun M. - cat
psl - noun M. - dog
dàn - noun M. - day
druż - noun M. - friend
kruh - noun M. - bread; loaf
sajt - noun M. - site; website
zpùsòb - noun M. - way; method
kmen - noun M. - stone
mr - noun M. - world
tepl - adj. - warm
kùkrn - adj. - corn
prwèdn - adj. - fair
dlòuh - adj. - long
duż - adj. - big; great; large
dòbr - adj. - good
slòwenk - adj. - slavic
lyczn - adj. - personal; own; private
zl - adj. - bad; evil
zlb - adj. - angry
durn - adj. - stupid
mal - adj. - small; little
tzudn - adj. - strange; weird
ùczeln - adj. - useful
czèstn - adj. - honest
hladn - adj. - cold
ryhl - adj. - fast
sdn - adj. - old
zlagn - adj. - general; common; mutual; generic
ran - adj. - early
czodn - adj. - weird; strange
smàczn - adj. - tasty
zbícs - adj. - excess
zwizc - adj. - usual
sùtrô - adv. - tomorrow
seniô - adv. - today
wètzô - adv. - yesterday
siewèô - adv. - now
czrô - adv. - few
wrlë - adv. - very
trícsnô - adv. - a little; not much
ë - conj. - and
a - conj. - but/and
ale - conj. - but
cze - conj. - or
jako - conj. - same as ...
czë - conj. - in order to
czöbnè - conj. - in order to not
cè - conj. - that
zcbò - conj. - because
inzcë - conj. - otherwise
ażne - conj. - except
nmà - prep. - ACC: no
w - prep. - ACC: into; LOC: in
prtwe - prep. - GEN: against/versus
ò - prep. - ACC: about
òb - prep. - ACC: over
sà - prep. - INS: with
dã - prep. - DAT: to, LOC: at/on
bliżèni - prep. - ACC: to front of, LOC: near/before
wcse - prep. - LOC: above
pod - prep. - LOC: under
bzë - prep. - INS: without
pdëbni - prep. - ACC: as
bò - prep. - ACC: for
z - prep. - ACC: from
nèż - prep. - than
ahòj - part. - hello/hi
tõcs - part. - too
jècsie - part. - more; yet
takè - part. - so/such
ly - part. - whether
dòbrijë - part. - welcome
aj - part. - yes
níj - part. - no
-dùr(ica) - suffix. - -er(femine)

to be (irregular verb)

infinitive: bëc

Present tense

1SG. jëm
2SG. jës
3SG. á
3SG.F. jëcs
3SG.INAN. jë
1PL. jëmy
2PL. jëst
3PL. jëż

Past/perfect tense

1SG. bëm
1SG.F. bmà
2SG. bël
3SG. bë
3SG.F. blà
3SG.INAN. be
1PL. blëm
2PL. blëti
3PL. bëż

Future tense

1SG. bjë
2SG. bjëcs
3SG. bje
3SG.F. bje
3SG.INAN. bjèst
1PL. bjëma
2PL. bjëty
3PL. bjëtz

Grammar

Adverb: -ô
Negation: nè-, written together with verbs and adverbs, except: sequences, to be able to, to be, to know, to can, to like, participles, and verbs that have prefix nè-
Comma should be placed before any conjunction, except 'ë' or 'cze' when it found between two nouns or two verbs in infinitive form.
Super-degree of adjective - -(cs)e
Diminutive - -(a)tk(e)-
Sub-degree of adjective - -(ñ)i

Case

Noun

MAS/NEU/FEM
Nominative(Nièmali) - (-Ø-)/(-ò-/-a-)/(-a-/-ë-)
Genitive(Ròdili) - (-a-/-òw-)/(-a-/-ëv-)/(-ë-/-ëv-)
Accusative(Winièli) - (-a-/-y-)/(-ò-/-a-)/(-ã-/-ë-)
Dative(Datiwi) - (-u-/-òm-)/(-u-/-am-)/(-ie-/-òm-)
Instrumental(Twòrci) - (-em-/-ama)/(-òm-/-amë-)/(-à-/-ami-)
Locative(Lòkèli) - (-ie-/-ach-)/(-ë-/-òch-)/(-ie-/-ach-)

Adjective

MAS/NEU/FEM
Nom. - (-i-/-i-)/(-ò-/-e-)/(-ë-/-ò-)
Gen. - (-ègò-/-ëch-)/(-ògò-/-òch-)/(-i-/-ich-)
Acc. - (-i-/-ë-)/(-ò-/-òch-)/(-à-/-è-)
Dat. - (-emu-/-im-)/(-u-/-òm-)/(-i-/-im-)
Ins. - (-im-/-ëma)/(-òm-/-òme-)/(-à-/-ima-)
Loc. - (-im-/-ëch-)/(-òm-/-u-)/(-i-/-ëch-)

Pronoun

to where - kùdë
to somewhere - kùdës
to anywhere - kùdëbô
where - gdiè
somewhere - gdiès
anywhere - gdiëbô
why - prczè
when - kògdy
sometime - kògdës
anytime - kògdëbô
how - jakcs
so - tmù
here - òcè
there - tòj

Who

Nom. - htò
Gen. - htù
Acc. - hà
Dat. - hmu
Ins. - hèm
Loc. - hti

Somebody

Nom. - htòs
Gen. - htùs
Acc. - hàs
Dat. - hmus
Ins. - hès
Loc. - his

Anybody

Nom. - htòbô
Gen. - htùbô
Acc. - hàsbô
Dat. - hmubô
Ins. - hmùbô
Loc. - hibô

Nobody

Nom. - nihcè
Gen. - znyhtúj
Acc. - znyhtàs
Dat. - nihmu
Ins. - znyhèm
Loc. - znyhi

What

Nom. - cò
Gen. - ceju
Acc. - cà
Dat. - cu
Ins. - cęm
Loc. - ci

Something

Nom. - còs
Gen. - cejus
Acc. - càs
Dat. - cùs
Ins. - cęs
Loc. - cis

Anything

Nom. - cëbô
Gen. - cëjubô
Acc. - càbô
Dat. - cùbô
Ins. - cębô
Loc. - cibô

Nothing

Nom. - znycò
Gen. - znycę
Acc. - znycõ
Dat. - znycmu
Ins. - znycèm
Loc. - znyci

which (M.) - ktòrny
which (F.) - ktòrna
which (N.) - ktòrnë
which (PL.) - ktòrni
own (M.) - swiè
own (F.) - swija
own (N.) - swę
own (PL.) - swià
every (M.) - kòżdi
every (F.) - kòżda
every (N.) - kòżdę
every (PL.) - kòżde

Common (M./N.)

Nom. - -/-
Gen. - -egò/-ech
Acc. - -ej/-ej
Dat. - -emu/-u
Ins. - -em/-em
Loc. - -im/-uj

Common (F.)

Nom. - -/-
Gen. - -ę/-ęj
Acc. - -eù/-eù
Dat. - -ej/-ej
Ins. - -ej/-e
Loc. - -ó/-ã

Common (PL.F.)

Nom. - -/-
Gen. - -ãj
Acc. - -ë
Dat. - -ãch
Ins. - -ëj
Loc. - -ã

(1SG/1PL)/(2SG/2PL)/reflexive

Nom. - 1(jó/më)/2(të/wa)/sebie
Gen - 1(mie/naju)/2(ce/wòs)/se
Acc. - 1(mià/nòs)/2(cà/was)/sà
Dat. - 1(mnie/nòm)/2(cë/wòm)/sòbie
Ins. - 1(mnã/nama)/2(tobã/wama)/sebã
Loc. - 1(mia/nõm)/2(cebi/wòs)/sòbia

(3SG/3SG.F/3SG.INAN)/3PL

Nom. - (òn/òna/ònò)/one
Gen. - (niegò/jè/jègò)/nich
Acc. - (jen/jà/je)/jich
Dat. - (jemu/niã/mu)/jim
Ins. - (nim/niã/onęm)/jima
Loc. - (nim/oni/ni)/nich

3PL.F

Nom. - ònã
Gen. - nãch
Acc. - jãch
Dat. - jãm
Ins. - jãmi
Loc. - nëch

1SG.POSS/1PL.POSS (M./N.)

Nom. - mòj(e)/nacs(ë)
Gen. - mòjegò/nacse
Acc. - mòjej/nacsej
Dat. - mòjemu/nacsu
Ins. - mòjem/nacsem
Loc. - mòjim/nacsuj

1SG.POSS/1PL.POSS (F.)

Nom. - mòja/nacsa
Gen. - mòę/nacsę
Acc. - mòjeù/nacseù
Dat. - mòjej/nacsej
Ins. - mòjej/nacse
Loc. - mòji/nacsã

1SG.POSS/1PL.POSS (PL.)

Nom. - mò/nacsę
Gen. - mòej/nacsej
Acc. - mòji/nacsie
Dat. - mòjem/nacsem
Ins. - mòje/nacsë
Loc. - mòji/nacsuj

2SG.POSS/2PL.POSS (M./N.)

Nom. - twòj(e)/wacs(ë)
Gen. - twòjegò/wacse
Acc. - twòjej/wacsej
Dat. - twòju/wacsu
Ins. - twòjem/wacsem
Loc. - twòjim/wacsuj

2SG.POSS/2PL.POSS (F.)

Nom. - twòja/wacsa
Gen. - twòę/wacsę
Acc. - twòjeù/wacseù
Dat. - twòjej/wacsej
Ins. - twòjej/wacse
Loc. - twòji/wacsã

2SG.POSS/2PL.POSS (PL.)

Nom. - twò/wacsę
Gen. - twòej/wacsej
Acc. - twòji/wacsie
Dat. - twòjem/wacsem
Ins. - twòje/wacsë
Loc. - twòji/wacsuj

3SG.POSS/3PL.POSS (M./N.)

Nom. - jiòj(e)/òjacs(ë)
Gen. - jòjegò/òjcse
Acc. - jiòjë/òjcsej
Dat. - jòjemu/òjcsu
Ins. - jòjem/òjcsem
Loc. - jòjim/òjcsuj

3SG.POSS/3PL.POSS (F.)

Nom. - jòja/òjcsa
Gen. - jòę/òjcsę
Acc. - jòjeù/òjcseù
Dat. - jòjej/òjcsej
Ins. - jòjej/òjcse
Loc. - jòji/òjcsã

3SG.POSS/3PL.POSS (PL.)

Nom. - jò/òjcsę
Gen. - jòej/òjcsej
Acc. - jòji/òjcsie
Dat. - jòjem/òjcsem
Ins. - jòje/òjcsë
Loc. - jòji/òjcsuj

(PROX/PROX.INAN/PROX.F)/PROX.PL

Nom. - (ten/sie/ta)/te
Gen. - (tegò/tegò/ti)/tich
Acc. - (tegò/tò/tã)/tëch
Dat. - (temu/temu/ti)/tëm
Ins. - (tim/tim/tõè)/tëmi
Loc. - (tim/tim/ti)/tich

(DIST/DIST.INAN/DIST.F)/DIST.PL

Nom. - (nen/nò/na)/tutam
Gen. - (nõ/negò/ni)/nich
Acc. - (nego/nò/nã)/nech
Dat. - (nemu/nemu/ni)/nëm
Ins. - (nim/nim/nõè)/nëmi
Loc. - (nim/nim/ni)/nich

Verb

Infinitive: -(ë)c for first declension, otherwise -Ø.
Imperative: -(j)më/-(ë)ce (plural.)
Passive: -(i)se

Participles

Participle - -(ò)ł- + case postfix
Passive participle - -(ò)n- + case postfix
Past participle - -(ë)le- + case postfix
Past passive participle - -(ò)ln- + case postfix
Past verbal participle - -(s)łcsë-
Present verbal participle - -(k)ãcë-
Gerund - -(i)ła

Declension I: -i/-y or -C

Present tense

1SG. -ã
2SG. -(è)cs
3SG. -Ø
3SG.F. -(à)ty
3SG.INAN. -(ò)tè
1PL. -(è)ma
2PL. -(è)ta
3PL. -(õ)sa
impersonal -è

Past tense

1SG. -(y)lë
1SG.F -(y)lã
2SG. -(è)l
3SG. -(y)lcs
3SG.F. -(y)la
3SG.INAN. -(ò)tlè
1PL. -(y)lë
2PL. -(y)litë
3PL. -(ë)ż
impersonal -(ë)lè

Perfect tense

1SG. -(y)lm
1SG.F. -(y)lmã
2SG. -(e)lcsë
3SG. -(y)lc
3SG.F. -(y)lca
3SG.INAN. -(y)lty
1PL. -(è)ly
2PL. -(è)lity
3PL. -(y)lż

Future tense

1SG. z(jè)- -(ã)m
2SG. z(jè)- -(è)cs
3SG. z(jè)- -(à)s
3SG.F. z(jè)- -(à)të
3SG.INAN. z(jè)- -(ò)st
1PL. z(jè)- -(e)m
2PL. z(jè)- -(e)ta
3PL. z(jè)- -(à)tz
impersonal -(e)lòcs

Declension II: -V, except -i

Present tense

1SG. -m
2SG. -cs
3SG. -Ø
3SG.F. -ty
3SG.INAN. -tèj
1PL. -më
2PL. -ta
3PL. -dża
impersonal -lè

Past tense

1SG. -lë
1SG.F. -lëm
2SG. -l
3SG. -lcs
3SG.F. -la
3SG.INAN. -lí
1PL. -lë
2PL. -litë
3PL. -ż
impersonal -lèż

Perfect tense

1SG. -lm
1SG.F. -lmã
2SG. -lcsë
3SG. -lc
3SG.F. -lca
3SG.INAN. -lò
1PL. -ly
2PL. -lity
3PL. -lż

Future tense

1SG. z(jè)- -m
2SG. z(jè)- -cs
3SG. z(jè)- -s
3SG.F. z(jè)- -të
3SG.INAN. z(jè)- -stò
1PL. z(jè)- -má
2PL. z(jè)- -ta
3PL. z(jè)- -tz
impersonal -tzè

Numbers

0 - nèmia
1 - òdièn
2 - dwô
3 - trô
4 - tzètô
5 - piat
6 - sièst
7 - sèm
8 - wosièm
9 - dèwiat 10 - dèsit
11 - òdièsit
12 - dwèsit
13 - trèsit
14 - tzèsit
15 - piasit
16 - sièsit
17 - sèsit
18 - wosit
19 - dèwisit
20 - dwacit
21 - dwacit òdièn
30 - tricit
40 - srôkcit
50 - piacit
60 - siecsit
70 - sèmsiat
80 - vòsècit
90 - dèwiacit
100 - sotnia
101 - sotnia òdièn
200 - dwèsti
300 - trôsta
400 - tzèsta
500 - piasta
600 - sièsot
700 - sèmsot
800 - wòsiècot
900 - dewiacot
1000 - tiasica
2000 - dwô tiasica
1000000 - miliòn
1000000000 - miliarde

Denáth language

Es Denáth ináith iDanhás. / Denáth is a language of Danhas.
WIP a posteriori conlang made upon of Gaulish, Celtic and Welsh languages.

Phonology

a - /æ/
á - /ɑː/
â - /ɑ̃/
b - /b/
c - /k/
ch - /χ/
d - /d/
dh - /ð/
e - /ɛ/
é - /eː/
ê - /ɛ̃/
f - /f/
fh - /ɸ/
g - /g/
gh - /ɣ/
h - /h/
i - /ɪ~j/
í - /ɪː/
î - /ĩ/
l - /l/
lh - /ɬ/
m - /m/
n - /n/
nh - /ŋ̊/
o - /ɒ/
ó - /ə/
ô - /ɔ̃/
oe - /œ/
p - /p/
r - /r/
rh - /ɾ̥/
s - /s~z/
sh - /ʃ/
t - /t/
th - /θ/
u - /ʊ/
ú - /uː/
û - /ũ/
v - /β/
w - /w/
Diphtongs: au, ai, ei, oi, ui.
Emphasis is always on the penultimate syllable.
Mutations:
p -> b;
t -> d;
c -> g;
b -> v;
d -> dh;
f -> fh;
g -> gh;
m -> w;
n -> nh;
l -> lh;
r -> rh;
sC -> Ø;
sV -> shV;
gw -> chw;
V -> hV;
Vn -> chV;
Vl -> chV.


Vowel harmony:
a -> e;
é -> i;
i -> é;
e -> ê;
o -> á;
á -> o;
u -> ú;
ú -> û;

Collisions:
V-V -> V-hV;
V-Vn -> V-chV;
V-Vl -> V-chV;
C-C -> C-iC.
Verb finals: l, b, r, n, s, o*, i*;
Noun finals: C, e*, u*, á,;
Adjective finals: C, a*, i*.
dhV + s.. -> s;
thV + s.. -> s;
sV + dhV -> dhV;
sV + thV -> thV;
VC + V -> VCV;
VCo* + V -> VCV;
VCV + V -> VCVV;
VC(VC)+V + V -> ..VCV.


Samples

Léná it fhanét iále wá nése co chán hifhamún.
/leːnɑː ɪt ɸɑneːt jɑːlɛ wɑː neːsɛ kɒ χɑːn hɪɸɑmuːn/
Léná it [f]anét iál-e wá nés-e co [ch]án [h]ifh-amún.
Lena DEF window open-PST CONJ close-PST EMP DEM.DIST TEMP-time

Lena opened the window, but closed it again at once.


í melá íw hadhétiná.
/ɪː mɛlɑː ɪːw hæðeːtɪnɑː/
í mel-á íw [h]adh[é]-tiná
1S go-PRS.PROG REFL.POS LAT-house

I am going to my home.


í côle a mó chéwáth gwáprela pâ wánó
/ɪː kɔ̃lɛ æ mə χeːwɑːθ ɡʷɑːprɛlɑ pɑ̃ wɑːnə/
í côl-e a mó [ch]éwáth gwáprel-a pâ [m]án-ó
1S believe-PST SR 1S.POS uncle cook-PRS very good-ADV

I thought that my uncle cooked very well.


sú éno et gále ós hon na chénoe
/suː eːnɒ ɛt gɑːlɛ əz hɒn næ χeːnœ/
sú éno et [c]ál-e ós [h]on na [ch]éno-e
3P win yet can-PST PERF but NEG win-PST

They still could have won, but they didn't.


í Dhoé gwéle osúiw pá ché íw vad rá chwrélá
/ɪː ðɒeː ɡʷeːlɛ ɒsuːjw pɑː χeː ɪːw βæd rɑː χʷreːlɑː/
í Dhoé gwél-e osúiw pá [ch]é íw [b]ad rá [gw]rél-á
1S Joe see-PST «last time» when 3S REFL.POS boat PST make-PRS.PROG

When I saw Joe earlier, he was building his boat.


Vocabulary

ámo - to love;
gní - to know;
gwó - to do;
côlí - to believe;
gwrél - to make / create;
gwél - to see;
lávar - to speak;
brís - to break;
ró - to give;
gwáprél - to cook;
inél - to say / tell;
prín - to buy;
mel - to go;
úrô - to find;
cál - to be able;
dír - to get back (something) / return;
éno - to win;
clâbó - to be sick;
gwíro - to hear;
réthi - to run;
gófo - to care;
ghéb - to become;
car - to carry;
gáil - to want / wish;
riwól - to rule / control;
iál - to open;
nés - to close;
bad - a boat;
cun - a dog;
lé - a place;
lír - a book;
tiná - a house / home;
gwén - a human / person;
ináith - a language / speech;
ové - a sheep;
calón - a heart;
ép - a horse;
fanét - a window;
éwáth - an uncle;
gwâl - a wool;
cerb - a wagon;
lwith - a load;
amún - a moment / time;
gwápu - a food;
náthá - a snake;
méná - a sign;
anér - down / a bottom;
dúnáthá - a poisonous snake;
clâ - sick;
trís - heavy;
ôlh - big / great;
célf - fast;
nówi - new;
mán - good;
pólh - hot;
slán - health;
dúli - poisonous;
osúiw - last time / previously;
na - negation / not (prefix);
o - yes/no interrogation (prefix);
mé - if (prefix);
et - yet (prefix);
rhí - too (prefix);
pá - when;
-(ch)ac - and;
wá - and (sentence separator);
on - but;
pâ - very;
rhái - please;
né - a lot of (countable items);
ethné - much/many (non-countable items);
ái - hortative particle;
co - emphasis particle;
a - clauses subordination / in order to / to
it - definitive article;

to be
Infinitive: bis;
Progressive: esi;
Past progressive: bá chós;
Present tense: es;
Perfect: ethí;
Past perfect: bú chós;
Future perfect: bí chós;
Conditional perfect: gwá wi;
Past tense: bú;
Future tense: bí;
Gerundive: bisé;
Participle form: búi;
Passive participle form: muí;
Conditional mood: mi.

Note: «to be»-verb follows the VSO word order.

to have
1S: íes;
2S: ties;
2S.F: túes;
3S: éches;
3S.F: úes;
1P: nies;
2P: íses;
3P: súes.


Grammar

Word order: Poss Adj Prep S O V IntO Adv,
or OSV for interrogation.

Pronouns

pé - what;
cé - who;
mái - where;
in - this;
án - that;
od - yon;
ei - it;
ích - here;
súi - reflexive;
íw - reflexive possessive;
mó - 1S possessive;
tó - 2S possessive;
ó - 3S possessive;
nó - 1P possessive;
vó - 2P possessive;
só - 3P possessive;
í / chí - 1S;
ti - 2S;
tú - 2S.F;
é / ché - 3S;
ú / chú - 3S.F;
ni - 1P;
ís / chís - 2P;
sú - 3P.


Prepositions / cases

adh(V)- - to / toward (LAT);
en(V)- - in / at (LOC);
án(V)- - inside;
ap(V)- - from (ABL);
er(V)- - around;
ré(ch)- - before;
tar(V)- - by / using;
i(ch)- - of (genetive);
can(V)- - with;
álh(V)- - without;
u(ch)- - to / for (dative);
ifh(V)- - at / in (TEMP).


Verbs

Infinitive: -Ø;
Progressive tense: -á;
Past progressive: rá + -á;
Present tense: -a;
Perfect: -thí;
Past perfect: -e + ós;
Future perfect: -sí + ós;
Conditional perfect: rá + -u;
Past tense: -e;
Future tense: -sí;
Gerundive: -é;
Passive form: -s;
Participle form: -úi;
Passive participle form: -dhí;
Impersonal form: -ig-;
Imperative form: -û;
Conditional mood: -u.


Nouns

Plural

C -> í;
e* -> a;
á -> ê.


Adjectives

Plural

C -> -ói;
a* -> e;
i* -> u.


Adverb

C -> -ó;
V -> -w.

Állánë language

Állánë álya (or simply Álláma) is my tiny personal artlang (a kind of constructed languages designed to be used in fictional worlds).

Phonology

a - /ɑ/
ae - /æ/, before consonant changes into [e]
e - /e/
ea - /eă/
i - /i/, /j/ after vowels, /ɪ/ at end of the word
o - /ɔ~ə/
u - /u/
p - /pʰ/
pp - /pʰː/
t - /ʈʰ/
tt - /tʰː/
nt - /nt/
l - /l/, /lʲ/ before [v]
ll - /lː/
ly - /ʎ/
ty - /c/
hy - /ç/
y - /j~ʲ/, /ʲ/ after [v]
lh/hl - /ɬ/
n - /n/
nn - /nː/
ng - /ŋ/
ny - /ɲ/
h - /x/
v - /v/
f - /ɸ/
w - /ʍ/
m - /m/
r - /r/
s - /s/
ss - /sː/
k/c - /kʰ/, written as [c] near consonant or at begin of the word
kk/cc - /kʰː/
þ - /θ/
ð - /ð/
q - /kʷ/
ts - /t͡s/
ya/ia - /ja/, but /ia/ after consonant
ye - /e/
yo - /ø/
yu/iu - /ju~ʊ/
Initials: vowels + t, l, ly, n, ny, p, m, c/k, lh/hl, þ, s, hy, h, f, v, w, q, ty, r
Finals: vowels + s, r, n, l, t, nt
Permitted: rq(but not rc), lty, nty, rty, hty, ft, sty, sq, lq(but not lc), nq(but not nc), kt, nw, lw, rw, tw, pt
[e] becomes short at end of the word after consonant.
Acute accent denotes long vowels, dieresis denotes short.
Circumflex denotes upstep of tone (/ꜛ/).

Stress rules

'S
'SS
S'SS
SS'SlS
SlS'Sl
'StSlS

Allama writing system (Álláni)


Samples

alvia êmeinalë - I have a cat.
alvia emen êhályein - I don't have a cat. (Formal register)
alvia nêmeinalë - I don't have a cat.
elessë êtta - I'm going home.
atius rêilenasan telaten énë - They two have written a letter to their friends.
á âpeleinan! - Don't do it!
âpelien purin - Do it good.
wâtólmestein Állámanan? - Do you speak Allane?
acló têtorso rûcarasan atel Þu Tan as ûstos ia aclol ciryan tulen - Zhu Dan shot the king's shoulder, but the king was still able to lead his army.
síra âquaþein? - What is your name? (lit. You named as what?)
ôisunca - It's raining.
ír elental? - Where are their houses?
së nesehó – atálán úma - To be, or not to be. That's question
tyú âyántein? - How are you?
tyú él? - How are you? (common speech variant)
is âilóra elel? - Why is the house running away?
savë! satyurein! êtyuras! - Hello – familiar, formal, more formal
þánákë íssan hyúnittánétyu - I am interested in your opinion.

centelesë êilcunein ruinelas e fallesë ettelútinan túlcátinanea, quéssá þélonea têisinanar, êiþáritullein quanin.
All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.
il âituleinar Elályal Íha,
il âimemeinar Elályal Íha,
sóvé âinélheinar Elályal Íha,
âisálcáleinarea Málallë.
One Ring to rule them all,
One Ring to find them,
One Ring to bring them all
And in the Darkness bind them.

íkuqual sûlmas tullon,
êlindein Cioto mélassë,
amár éa í Cioto mélallë.
京にても京なつかしやほととぎす
(a hokku by Matsuo Bashō)


Vocabulary


Grammar

Word order: SubordinateClause Conjunction Syntactic CaseModifier QuestionPronoun Object ChainedVerb IndirectObject Verb Adverb Subject Adjective PossesivePronoun Preposition
Note: some suffixes may be reversed in order to avoid vowel/vowel or consonant/consonant collisions (e.g. -esan- -> -nase-).
Also the suffixes that don't consist from a single vowel can «eat» the preceding vowel, otherwise [w] is appended to avoid the collision.

Suffixes

-s- - BE-verb
-t- - EXIST-verb
-llét- - BE.LOC-verb
-(á)ttán- - DEF
-ellánt- - iterative aspect
-itull- - jussive
shá(ly)- - already
-esan- - probably ...
-ehyár- - Opinion mood: to have an opinion that ...
-úss- - Uncertain mood: to don't be sure that ...
-ályél- - Sudden mood: suddenly ...
-ontál- - Potential mood: maybe ...
-úllúr- - Happy mood: to be happy to ...
-asal- - to let/allow to ...
-intel- - to want to ...
-ilént- - to have to ...
-ály- - to should have to ...
-est- - to be able to ...
-esér- - to know how to do ...
-ittél- - to «shall» ...; to «must» ...
-átten- - -ism
-éruin- - -er (person)
-ályít- - to get something to ...; to force something to ...; to make something/somebody to ...
-isás- - DIM (diminutive)
-énás- - un-
-ólyán- - anti-
-áttés- - pro-
-ás- - -ing (repeating action)
-ásses- - -er (tool / instrument)
-ánál- - -land; land of ...
-úntil- - dis-
-úsus- - un-; undo
-áhyint- - de-; out of ...
-akál- - re-; again ...
any(á)- - very (emphatic particle for descriptives)
-ólhén- - -inary/-imal
-áþál- - plant bearing ...
-áþúhy- - place where ...
-úllúr- - mono-
-irél- - reciprocal voice
-(ny)álë- - descriptivisation
-átte- - nominalizer (doesn't create a new meaning)
-áhyni- - nominalizer (creates a new meaning)
-(hy)álvú- - insult suffix
-(t)áhyá(l)- - despicable/pejorative suffix
-(h)úntú(ly)- - admonitive mood
-(ny)álytú- - -ful (forms a descriptive)
-(ú)nten- - common verbalisation

Common negation prefix is n(e)- (roughly equivalent to non-)
Verbal negation may be expressed by chaining with a «hályen» verb (more formal way) means «to not do».
There're two ways to write answers for the yes/no-questions: by repeating of the verb (more formal/polite way) or via the corresponding words (see the vocabulary).

Conjugation of the irregular verb «to be»

In common speaking the «be»-like verbs could be omitted at all.
Note: subject of the «be»-like verbs is denoted by the absolutive case, but object is denoted by the instrumental case.

Infinitive:

1S
Present/progressive: es
Past: sum
Future: res
Perfect: tu
Conditional: ea
Imperative: esí
Present participle: ris
Past participle: ros
2S
Present/progressive: et
Past: met
Future: ret
Perfect: nar
Conditional: ear
Imperative: esë
Present participle: tis
Past participle: tos
3S/3S.INAN
Present/progressive: em
Past: mes
Future: ren
Perfect: tar
Conditional: rum
Imperative: em
Present participle: nis
Past participle: nos
1P/D
Present/progressive: nar
Past: fes
Future: ron
Perfect: enë
Conditional: eur
Imperative: nar
Present participle: euvis
Past participle: euvos
2P/D
Present/progressive:
Past: emë
Future: fen
Perfect: rom
Conditional: eunë
Imperative:
Present participle: eunis
Past participle: eunos
3P/D
Present/progressive: en
Past: fan
Future: ran
Perfect: ten
Conditional: eun
Imperative: en
Present participle: enis
Past participle: enos


Demonstratives

Proximal: ú/-(a)më
Distal: iú/-(a)në
Proximal.D: énet/-(e)net
Distal.D: iér/-(i)ér
Proximal.P: ié/-(i)élya
Distal.P: iún/-(i)ún


Pronoun

1S+2S: tiri
1S+3S: elyë
2S+3S: nil
1S: í
2S: é
2S.F: ul
2S POL: ear
3S: én
3S.F: sá
3S.INAN: lé
1D: ní
2D: tu
2D.F: úr
3D: énë
3D.F: sa
3D.INAN: let
1P: llá
2P: tyé
3P: wé
4: tá

all; everybody: il
everything: sóvé
each; every: állya
this: úma; -(l)úmá
that: iúma; -(l)iúmá
this; it (noun): lén
that (noun): lún
these two: énema
those two: iérama
these: iéma
those: iúnama
what: er
who: lír
what/which: síra
where: ír
which one: nyólí
how: tyú
something: misë
somebody; someome: nólva
why: is
there: ámë
here: síva
yon: lúþi
myself: lhí
yourself: ólí
himself: þí
ourselves: ólví
yourselves: ólvarí
themselves: tyárí

Possesion

1S: -(é)lyé
2S: -(é)tyu
2S.F: -(á)tái
3S: -(é)nyé
3S.F: -(a)sya
3S.INAN: -(a)lya
1D: -(a)nyat
2D: -(a)tyat
2D.F: -(u)túr
3D: -(a)llat
3D.F: -(a)sa
3D.INAN: -(e)le
1P: -(á)llá
2P: -(é)tyé
3P: -(a)la
Refl.: -(a)n


Adjective

All adjectives end in [a] or [e].
Sg. / Du. / Pl. / Cl.
-/-ië/-i/-së
Super-degree (>): râ-
Sub-degree (<): rû-
Equal-degree (=): vô-
Max-degree: (the ...-est): mô-
Negative max-degree: (the non-...-est): nyê-
Adverb: -in


Noun


Case and number


Declension I (end in vowel)

Sg. / Du. / Pl. / Cl.
Abs. (transitive patient or intrasitive agent) - /-r/-nt/-s
Erg. (transitive agent) - -l/-lar/-lat/-las
Dat. (to/for) - -n/-[e]in/-të/-së
Gen. (of) - the last vowel becomes long, but short if it's already long/-ron/-ton/-tos
Pos. ('s/of) - -(n)i/-(n)ir/-(n)int/-(n)is
Ins. (by/with/using) - -nan/-linan/-tinan/-në
All. (to/in) - -ssë/-nnar/-nnat/-nnas
Abl. (from) - ê- -r/ê- -n/ê- -t/ê- -s
Loc. (at/in) - -llë/-llan/-llet/-lles
Ade/Sup. (on) - â- -r/â- -res/â- -ret/â- -rus
Sup. II (above) - ê- -l/ê- -r/ê- -nt/ê- -s
Sub. (under) - ês-/ês- -r/ês- -t/ês- -s
Ill. (into) - êt-/êt- -r/êt- -t/êt- -s
Ela. (from inside of) - êl-/êl- -r/êl- -t/êl- -s
Per. (through/along) - ât-/ât- -r/ât- -t/ât- -s
Pro. (by way of/through) - ât- -nis/ât- -ris/ât- -tis/êl- -s
Cnt. (against) - ît-/ît- -r/ît- -t/ît- -s
Con. (with) - ûs-/ûs- -r/ûs- -t/ûs- -s
Inc. (without) - ôt-/ôt- -r/ôt- -t/ôt- -s
Abi. (in front of) - ôs-/ôs- -r/ôs- -t/ôs- -s
Ben. (to/for) - -ssan/-ssar/-sset/-lis
Sem. (like as/as) - -va/-var/-van/-vier
Tem. (at time) - -llon/-llor/-llont/-llos
Cau. (due/because) - -nna/-livar/-lint/-livas
Voc. (vocation) - îs-/îs- -r/îs- -nt/îs- -s


Declension II (end in consonant)

Sg. / Du. / Pl. / Cl.
Abs. - /-ar/-ant/-as
Erg. - -al/-alar/-alat/-alas
Dat. - -an/-a[e]in/-atë/-asë
Gen. - -ál/-aron/-aton/-atos
Pos. - -i/-ir/-int/-is
Ins. - -anan/-alinan/-atinan/-anë
All. - -assë/-annar/-annat/-annas
Abl. - ê- -ar/ê- -an/ê- -at/ê- -as
Loc. - -allë/-allan/-allet/-alles
Ade/Sup. - â- -ar/â- -ares/â- -aret/â- -arus
Sup. II - ê- -al/ê- -ar/ê- -ant/ê- -as
Sub. - ês-/ês- -ar/ês- -at/ês- -as
Ill. - êt-/êt- -ar/êt- -at/êt- -as
Ela. - êl-/êl- -ar/êl- -at/êl- -as
Per. - ât-/ât- -ar/ât- -at/ât- -as
Pro. - ât- -anis/ât- -aris/ât- -atis/êl- -as
Cnt. - ît-/ît- -ar/ît- -at/ît- -as
Con. - ûs-/ûs- -ar/ûs- -at/ûs- -as
Inc. - ôt-/ôt- -ar/ôt- -at/ôt- -as
Abi. - ôs-/ôs- -ar/ôs- -at/ôs- -as
Ben. - -assan/-assar/-asset/-is
Sem. - -ava/-avar/-avan/-avier
Tem. - -allon/-allor/-allont/-allos
Cau. - -enna/-alivar/-alint/-alivas
Voc. - ût-/ût- -ar/îs- -ant/îs- -as


Verb

All verbs should end in the -en postfix.

Agent

1S: ê-
2S: â-
3S: û-
3S.INAN: âi-
1P/D: ô-
2P/D: î-
3P/D: êi-
IMPRS.SG: ôi-
IMPRS.DU/PL: ûi-
4: îo-


Patient

1S: -(a)m
2S: -(a)s
3S: -(a)lë
3S.INAN: -(a)n
1P/D: -(a)lyë
2P/D: -(a)t
3P/D: -(a)r
4: -(ei)ti

Tense and mood

Conditional: -ám
Present: -ein
Progressive: -a
Past: -os
Future:
Imperfect: -i
Habitual: -ól
Passive habitual:
Passive imperfect: -ir
Passive present: -er
Passive progressive: -an
Passive past: t- -us
Passive future: t- -ena
Future progressive: s- -o
Passive future progressive: t- -o
Perfect: s- -as
Imperative: -ië
Admonitive: -ia
Prohibitive: -iú
Gerund: s(a)- -ein
Present participle: r- -is
Past participle: r- -os
Passive present participle: s- -us
Passive past participle: t- -an
Interrogation: w(a)-


Numbers

áe – minus, e.g. télsanë áe - -15.
pó - dot, e.g. síli pó hyétélsákalásí - 2.572.
-to(n) – fraction, e.g. þélyé viloton OR þetolor - 3/4.
télcá tosísea - 7 1/2.
tei - 0
íha / -ha - 1
síli / se- -sí - 2
þélyé / þe- -lyé - 3
vilo / vi- -lor - 4
hyélë / hyé- -hë - 5
hlúni / hlú- -në - 6
télcá / té- -lá - 7
þlú / þlé- -lú - 8
nesta / ne- -ta - 9
télsa - 10
télsáka - 100
télsála - 1000
ténésa - 1000000
tetyá - 1000000000

E.g.:
sevilo - 24;
þehyélë - 35;
hlúnilyé - 63;
þlétélsákalá - 870;
hyétélsákatalor - 594.

Xy logo

Xy programming language

Xy is a minimalistic semi-functional stack-based language inspired by Joy, Cats and Factor.


Samples

(* Recursive factorial *)
:fac
  dup 0 =
  [pop 1]
  [dup pred it *] if;

(* Iterative factorial *)
:faci
  1 ->i iota [$i * ->i] step $i !i;

(* Iterative factorial, second variant *)
:fac#2 dup ->N pred ->C
  $N $C [dup pred] times
  $C `* times !!;

(* Recursive fibonacci *)
:fib
  dup 2 <
  `ret
  [pred dup it swap pred it +] if;

(* Prints the fibonacci sequence *)
:fibs
  0 swap succ range [fib say] step;

(* Iterative fibonacci *)
:fibi
  0 ->a 1 ->b 0 ->t
  [$a $b + ->t $b ->a $t ->b] times
  $a !!;


Downloads

The interpreter is WIP. Please stand by...


Quick reference

usage: xy [-isah?] [-e code] [-l file] [file] [args...]
       file     loads and executes file.
       -i       starts interactive mode.
       -s       reads code from the stdin.
       -a       enables safe mode (no access to the OS).
       -e code  executes the code.
       -l file  loads file.
       -h       prints this messsage.
Xy language integrated manual.

! Quick syntax overview

(* aaa *)                             comment
dup  dip  *  equals?                  words
True  False                           boolean
Nil                                   nil
:sq dup *;                            define a new word
@pi0.5 Pi 0.5 *;                      define a constant
56 ->x                                set a variable
$x                                    get the variable
!x                                    delete the variable
!!                                    delete all variables
1  1.45  1707  44.6  0.33             numbers (arbitrary precision)
"aaa\naaa"                            string
$"aaa\naaa"                           non-escaped string
{}   {1 2 3} {{1 2} "a"}              lists
:{}  :{{"key" "value"}  {1 8.3}}      tables
[*]  [dup *]                          functions
`dup                                  shortcut for [dup]

! Regular expressions syntax
!!!metacharacters:
  .         matches any single character.
  \         escapes the next character.
  ^         matches the beginning of line.
  $         matches the end of line.
  |         alternation.
!!!brackets:
  ()        grouping.
  []        character class.
  [a-z]     character range.
  (?mis)    sets flags: m - multiline, i - case insensitive, s - stretchy.
  [:...:]   special character class.
  (?^...)   negative grouping.
  (?=...)   positive lookahead.
  (?!...)   negative lookahead.
  (?<=...)  positive lookbehind.
  (?...)   atomic grouping.
  (?0..9)   calls subgroup.
  (?<...>)  calls named subgroup.
  (?N:...)  refers named subgroup.
  (?N<...>) named grouping.
  (?:...)   subpattern.
  (?|...)   resetting grouping.
!!!special character classes:
  [:x:]     [0-9A-Fa-f]
  [:d:]     [0-9]
  [:s:]     [ \t\n\r\f\v]
  [:N:]     [^\n]
  [:a:]     [A-Za-z]
  [:o:]     [A-Za-z_]
  [:w:]     [A-Za-z0-9_]
  [:l:]     [a-z]
  [:u:]     [A-Z]
  [:p:]     [-!"#$%&'()*+,./:;<=>[email protected][\\\]^_`{|}~]
!!!escapes:
  \x...     matches character with the specified hexadecimal code.
  \o...     matches character with the specified octal code.
  \d        matches any digit.
  \D        matches any non-digit.
  \s        matches any space character.
  \S        matches any non-space character.
  \w        matches any alphanumeric character.
  \p{...}   matches any character within the specified Unicode property.
  \N{...}   matches a character by its Unicode name.
  \0..9     backref.
  \K        sets match start.
  \A        matches the beginning of the subject.
  \Z        matches the end of the subject.
  \b        matches at word boundary.
  \B        matches at not word boundary.
  \Q        starts literal.
  \q        terminates literal.
!!!quantifiers:
  *         match 0 or more times.
  +         match 1 or more times.
  ?         match 0 or 1 times.
  {n}       match n times.
  {n,m}     match n to m times.
  {n,}      match at least n times.
  {,n}      match at most n times.

! FFI to the C language

It is possible to write native libraries for Xy in the C language.
!!!sample:
#include "xyex.h"

xy_val_t v;
INIT {
  v = xy_make_string("test!");
}

VARDEF(a, v);

FUNDEF(t) {
  xy_setvar("top!", xy_top());
}

EXPORT(2) {
  FUN("t", 1, t),
  VAR("a", a),
};

!!!compile:
$ cc -shared -fPIC lib.c -o lib.so
!!!use:
%> "./lib.so" use

%> a
  "test!"
%> 5 t
  "test!" 5
%> ?top!
  "test!" 5 5

!!!note: look inside `xyex.h` to see more interface functions.
! Built-in primitives

!!!note: shortcuts:
    N for Number, B for Boolean,  S for String,
    L for List,   F for Function, V for Value,
    T for Table.
!!!e.g. XN means argument X of type number.
!!!U after the primitive name means that this primitive is declared as a user-defined word.

Pi ( => N)
  Pushes the pi number.
E ( => N)
  Pushes the e number.
Tau U ( => N)
  Pushes the tau number.
Nil ( => V)
  Pushes nil.
True ( => B)
  Pushes true.
False ( => B)
  Pushes false.
Args ( => L)
  Pushes a list of the command line arguments.
safe-mode? ( => B)
  Tests whether the safe mode is enabled.
set-prec! (XN => )
  Sets numbers' precision to X.
prec? ( => N)
  Pushes the current numbers' precision.
help ( => )
  Prints this manual.
help-for? (XS => )
  Searches for X in the manual.
exit (XN => )
  Exits from the program with code X.
quit U ( => )
  Exits from the program with code 0.
stack ( => L)
  Pushes the stack as a list.
set-stack! (XL => ...)
  Sets X as the stack.
measure U (XF => N)
  Executes X, pushes amount of seconds elapsed for execution.
eval! (XS => ...)
  Executes X as a piece of code.
body? (XS => F)
  Pushes the body of user-defined word X.
here? (XS => B)
  Tests whether variable X exists.
defined? (XS => B)
  Tests whether user-defined word X exists.
constant? (XS => B)
  Tests whether X is defined as constant.
clear ( => )
  Clears the stack.
load (XS => ...)
  Loads and executes file X.
use (XS => ...)
  Loads native library X.
brk ( => )
  Stops execution of the currently running loop. Works inside of linrec, tailrec, while, times, step, steps, cond, twice and thrice.
ret ( => )
  Stops execution of the currently running function or word.
rew ( => )
  Stops execution of the currently running word.
it (... => ...)
  Recursively executes the currently running user-defined word. Always equals nil outside of a word.
this (... => ...)
  Recursively executes currently running function. Always equals nil outside of a function.
throw (XS => )
  Throws user-specific error X.
catch (XF YF => ...)
  Tries to execute X, if an error thrown while executing X, pushes the error message on the stack and executes Y.
say (X => )
  Writes the top of stack to the screen, puts a line break.
put (X => )
  Writes the top of stack to the screen.
getline ( => S)
  Reads a line from standard input, pushes it.
input (XS => S)
  Prints X on the screen, reads a line from standard input, pushes it.
nl U ( => )
  Puts a line break.
= (X Y => B)
  Tests whether X is equal to Y.
\= U (X Y => B)
  Tests whether X is not equal to Y.
> (X Y => B)
  Tests whether X is greater than Y. 
< (X Y => B)
  Tests whether X is less than Y.
>= U (X Y => B)
  Tests whether X is greater than or equals Y.
<= U (X Y => B)
  Tests whether X is less than or equals Y.
and (X Y => B)
  Tests whether both X and Y are truthy.
or (X Y => B)
  Tests whether either X or Y is truthy.
not (X => B)
  Pushes false if X is truthy, else pushes true.
neg (XN => N)
  Negates sign of X.
fac (XN => N)
  Pushes factorial of X.
+ (XN YN => N)
  Pushes the result of adding numbers X and Y.
- (XN YN => N)
  Pushes the result of subtracting numbers X and Y.
/ (XN YN => N)
  Pushes the quotient of numbers X and Y.
% (XN YN => N)
  Pushes the remainder of dividing number X by number Y.
^ (XN YN => N)
  Pushes X raised to the Yth power.
dup (X => X X)
  Pushes a new copy of X.
dupd (X Y => X X Y)
  Pushes a new copy of X, then pushes Y.
dup2 (X Y => X Y X Y)
  Pushes new copies of X and Y.
nip (X Y => Y)
  Pops second element out of the stack.
rip (X Y Z => Y Z)
  Pops third element out of the stack.
over (X Y => X Y X)
  Pushes a new copy of X.
tuck (X Y => Y X Y)
  Swaps X and Y, pushes a new copy of Y.
pick (X Y Z => X Y Z X)
  Pushes a new copy of X.
dip (X YF => ... X)
  Pushes X, executes Y, pushes a new copy of X.
rotate (X Y Z => Y Z X)
  Moves X to top of the stack.
roll (X Y Z => Z X Y)
  Moves Z deeper into stack.
swap (X Y => Y X)
  Swaps positions of X and Y.
swapd (X Y Z => Y X Z)
  Swaps positions of X and Y, then pushes Z.
pop (X => )
  Pops X out of the stack.
rev (X Y Z => Z Y X)
  Reverses the order of first three elements on the stack.
while (XF YF => ...)
  Executes Y, while X yields a truthy value.
times (XN YF => ...)
  Executes Y X times.
if (X YF ZF => ...)
  If X is truthy, executes Y, otherwise executes Z.
branch (XF YF ZF => ...)
  Executes X, if that yields something truthy, executes Y, otherwise executes Z
then (X YF => ...)
  If X is truthy, executes Y.
cond ({{XF YF} ... ZF} => ...)
  Executes each X. If that yields something truthy, executes corresponding Y and exits. If no one Y was executed, executes Z.
execute (XF => ...)
  Executes X.
x (XF => ...)
  Shortcut for "execute".
twice (XF => ...)
  Executes X twice.
thrice U (XF => ...)
  Executes X three times.
range (XN YN => L)
  Pushes a list of integers in range from X to Y.
iota U (XN => L)
  Pushes a list of integers from 1 to X (inclusive).
nth (XN YL|S => V)
  Pushes Xth element of Y.
cons (X YL => L)
  Appends X to the beginning of Y.
swons U (XL Y => L)
  Equivalent for "`cons flip".
uncons (XL => V L)
  Pushes separately head and tail of X.
head U (XL => V)
  Pushes the head of X.
tail U (XL => L)
  Pushes the tail of X.
shunt U (XL YL => L)
  Moves all items from Y to X reversively.
reverse U (XL => L)
  Reverses the order of elements in X.
in? (X YL|S|T => B)
  Tests whether X is present in Y.
to-chars! (XS => L)
  Breaks X into list of the characters.
ltrim U (XS => S)
  Removes space characters from the left side of X.
rtrim U (XS => S)
  Removes whitespace characters from the right side of X.
trim U (XS => S)
  Removes whitespace characters from the both sides of X.
find! (X YT => V)
  Extracts the value of key X in Y.
insert! (X Y ZT => T)
  Inserts key X with value Y into Z.
remove! (X YT => T)
  Removes key X from Y.
cat (XS|L YS|L => S|L)
  Concatenates X and Y.
concat U (XL => S)
  Concatenates all elements of X.
append (X YL => L)
  Appends X to Y.
extend U (XL YL => L)
  Extends Y with elements from X.
set! (XN Y ZL|S => L|S)
  Sets Xth element of Z to Y.
lower! (XS => S)
  Converts X to lower case.
upper! (XS => S)
  Converts X to upper case.
substr (XN YN ZS => S)
  Extracts substring of Z from X to Y.
subslice U (XN YS => S)
  Extracts substring of X from X to end.
cut! (XN YN ZS => S)
  Cuts away substring of Z from X to Y.
stringify (X => S)
  Converts X into string.
parse-number (XS => N)
  Converts X into number.
flip U (X Y ZF => ...)
  Interchanges X and Y, then executes Z.
succ U (XN => N)
  Increments X.
pred U (XN => N)
  Decrements X.
isolate (XL YF => L)
  Executes Y using X as the stack, returns modified X as a list.
linrec (XF YF ZF WF => ...)
  Executes X. If that yields a truthy value, executes Y, otherwise executes Z and W, then recurses. 
tailrec (XF YF ZF => ...)
  Executes X. If that yields a truthy value, executes Y, otherwise executes Z and then recurses.
step (XL YF => ...)
  One by one pushes elements of X, executes Y for each.
steps U (XS YF => ...)
  Same as "step", but for strings instead of lists.
map (XL YF => L)
  One by one pushes elements of X, executes Y for each, collects everything into a new list.
filter (XL YF => L)
  One by one pushes elements of X, executes Y for each, collects everything into a new list, filtering values for which X did not yield a truthy value.
fold (XL Y ZF => ...)
  Pushes Y, one by one pushes elements of X, executes Z for each pair.
size? (XL|S|T => N)
  Pushes count of elements/characters in X.
reduce U (XL YF => ...)
  Equivalent for "swap uncons swap rotate fold"
sum U (XL => N)
  Equivalent for "`+ reduce"
product U (XL => N)
  Equivalent for "`* reduce"
drop (XN YL => L)
  Drops X first elements of Y.
drop1 U (XL => L)
  Drops first element of X.
drop-last U (XL => L)
  Drops last element of X.
take (XN YL => L)
  Takes X first elements of Y.
take1 U (XL => L)
  Removes all but the first element of X.
last (XL|S => V)
  Pushes the last element of X.
enlist U (X => L)
  Puts X into new empty list.
empty? U (XS|L|T => B)
  Tests whether X contains nothing.
nullary U (XF => V)
  Executes X in an isolated copy of the stack. Pushes top of that stack.
unary U (X YF => V)
  Executes Y in an isolated copy of the stack. Pushes top of that stack. Pops out X.
binary U (X Y ZF => V)
  Executes Z in an isolated copy of the stack. Pushes top of that stack. Pops out X and Y.
ternary U (X Y Z WF => V)
  Executes W in an isolated copy of the stack. Pushes top of that stack. Pops out X, Y and Z.
code? (XS => N)
  Pushes code of the first character in X.
char! (XN => S)
  Pushes a character with code X.
format (XL YS => S)
  Formats Y using values from X. Use $N to refer the Nth element of X or [email protected] to refer relative element.
match? (XS YS => B)
  Tests whether X matches against regular expression Y.
find-all (XS YS => L)
  Extracts all occurences of regular expression Y in X.
split (XS YS => L)
  Splits X by regular expression Y.
join U (XS YL => S)
  Intercalates Y with X.
replace (XS YS ZS => S)
  Replaces all matches of regular expression Z by Y in X.
erase U (XS YS => S)
  Deletes all matches of regular expression Y in X.
time? ( => N)
  Pushes the current timestamp.
format-time (XN YS => S)
  Formats Y using timestamp X.
wait (XN => )
  Pauses execution for X milliseconds.
waits U (XN => )
  Pauses execution for X seconds.
exists? (XS => B)
  Tests whether file X exists.
file? (XS => B)
  Tests whether X is file.
directory? (XS => B)
  Tests whether X is directory.
slurp (XS => S)
  Reads the contents of file X.
write (XS YS => )
  Writes X to file Y.
call (XS => S)
  Executes system command X, pushes output of it.
shell (XS => S)
  Executes system shell command X, pushes output of it.
rmfile (XS => )
  Removes file X.
rmdir (XS => )
  Removes directory X.
mkdir (XS => )
  Creates a new directory X.
listdir (XS => L)
  Pushes a list of files in directory X.
walkdir U (XS => L)
  Pushes a list of files in directory X (recursively).

valkyrja logo

valkyrja programming language

Valkyrja is a K-inspired tacit array-based programming language.

Samples

/ Hello world
sayln "Hello, world!"

/ Hello world variant II
"Hello, world!"

/ Factorial
fac:{*/1+!x}

/ Sort
sort:{x@<x}

/ Calculate Nth fibonacci number
fibn:{:[x<2;1;it(x-1)+it(x-2)]}

/ Calculate fibonacci numbers
fib:{fibn'!x}


Brainfuck interpreter
Program which prints the 99 Bottles of Beer song lyrics


Downloads

The newest available version is 0.7α0602.
You can find it here.


Reference (0.7α0602)

Syntax

/ starts a line comment (should be prefollowed with one or more spaces/tabs);
a:1 is an assignment;
f:{x+y+z} defines a function. Functions can be anonymous. Functions can have up to three arguments: x, y, z; or don't have them at all (function takes no arguments called nillad);
it {:[x=0;1;x*it x-1]} reference to the current function;
1 1`000`000 0xff 0b1011 0o231 integer;
1.0 1. .1 float;
1 0 boolean;
`"a" character;
"hello" "a\nb\nc" string;
`s symbol;
` empty symbol;
nil nil;
1 2 3 [1;2;3] 1, 2, 3 vector;
[1 2 3;4 5 6] matrix;
[] empty vector;
`[[`key;"value"];[`key2;6]] dictionary;
:[cond1;clause1;...;condN;clauseN(;else)] condition;
:{expr1;expr2;...;exprN} block;
{x+y} {6} {x+1} function;
{x} 5 {x+y}(5;5) 5 {x+y} 5 application;
+ - # verb;
-5 5+5 verb application;
{x+y}(5;) *(;2) partial application;
3{x+1}/3 adverb.


Verbs

+ monadic flip. transpose a matrix.
+ dyadic plus. add numbers together.
- monadic negate. swap the sign.
- dyadic minus. substraction.
* monadic first. first element of vector x.
* dyadic times. multiplication.
% monadic reciprocal. divide 1 by x.
% dyadic divide. division.
| monadic reverse. reverse order of a vector.
| dyadic max/or. for numbers: larger one of x and y, for booleans: x or y.
& monadic where. &0 0 1 0 3 yields 2;4,4,4.
& dyadic min/and. for numbers: smaller one of x and y, for booleans: x and y.
^ monadic shape. #elts at each depth.
^ dyadic power. raise x to the exponent y.
! monadic enumerate/eval. for integers: build range from 0 to x (inclusive); for dictionaries: yield list of keys in dict x; for strings: evaluate string x as an expression.
! dyadic remainder. remainder of x and y.
< monadic grade-up. indices of vector sorted ascending.
< dyadic less. is x less than y.
> monadic grade-down. indices of vector sorted descending.
> dyadic more. is x greater than y.
= monadic group/values. for vectors: =3 4 3 4 4 yields <0;2>;<1;3,4>, for dictionaries: yield list of values in dict x.
= dyadic equals. is x equals to y.
~ monadic not. logical negation of x.
~ dyadic match. is x equals to y, type-intolerant, atomic.
@ monadic atom. is x an atom?
@ dyadic at/range. if x is vector: element at index y from vector x; if x is dictionary: get key y; if x is function: apply x to y; if x is integer: yield a range of integers from x to y.
# monadic size. for vectors and strings: length of x, for characters: ASCII-code of x
# dyadic take. if x is integer: repeat y for x times; for vectors: take element by index from matrix, eg. [1 2 3;3 4 6]#0 1 yields 2, if y is integer: fill y elements from x.
, monadic enlist. put x into a 1-element vector.
, dyadic join. join two vectors into one.
_ monadic floor. tolerant floor of x.
_ dyadic drop/chunk. remove y elements from vector x or split vector y into x chunks.
? monadic unique. for integers: convert int x into char; for vectors: distinct elements from vector x
? dyadic find/sample/deal/try. if x is function: apply x to y and check for errors, on error yield 1;message otherwise 0;result; if x is integer: yields x random elements from vector y, for integers: yields x random integers < y, if y is vector: yields index of y in vector x; for dictionaries: yields value of entry y in the dictionary x.
$ monadic format. cast x to string.
$ dyadic form. cast x to type of y; if x is string and y is a symbol `x, convert hexadecimal number x to integer.
|: monadic empty. yields true if x is empty or nil.
~: dyadic regmatch. match regex (GNU) x against string y.
?: dyadic regfind. find all occurences of regex (GNU) x in string y; yields list of pairs: start;end of substrings.
$: dyadic regextract. extract all occurences of regex (GNU) x in string y; yields list of substrings.
: dyadic S bind. bind symbol x to y.
:: dyadic S bindlocal. bind symbol x to y locally.
+: dyadic S bind plus. x:x+y.
-: dyadic S bind minus. x:x-y.
*: dyadic S bind times. x:x*y.
%: dyadic S bind divide. x:x%y.
,: dyadic S bind join. x:x,y.
_: dyadic S bind drop. x:x_y.
@: dyadic S bind item. eg. x:!3;[email protected]:5 0 yields 5;1,2; 4 4 [email protected]:4 2 yields 4;4,4; `[email protected]: in order to not modify x
#: dyadic S bind item in depth. eg. x:[1 2 3;4 5 6];x#:1337 1 0 yields <1;2,3>;<1337;5,6>; `x#: in order to not modify x


Adverbs

/ dyadic over. fold the vector y with x. eg. +/1 2 3 yields 6.
/ triadic while/iterate. if x is number: apply y to z x times, if x is function: apply y to z while x evaluates to true. eg. {x<10}{x+1}/3 yields 10.
/: dyadic until. apply until fixed-point is reached (y = x y)
\: dyadic scan-until. apply until fixed-point is reached collecting all intermediate results.
<: triadic each-left.
>: triadic each-right. eg. 2#>:["x";"y";"z"] take each right.
\ dyadic scan. fold the vector y with x collecting all intermediate results. eg. +\1 2 3 yields 1;3,6.
\ triadic scan-iterate. apply y to z x times collecting all intermediate results.
' dyadic each. apply x to each element of y. eg. !'1 2 3 yields <0>;<0;1>,<0;1,2>.
' triadic each. eg. "abc",'"def" join each.
': dyadic each-pair. pairwise apply x to each element of y.


Builtins

say monadic write x to the stdout.
sayln monadic write x and a newline to the stdout.
jsn monadic parse JSON string x.
jsr monadic represent x as a JSON string (serialize).
iota monadic yield a range of integers between 1 and x (inclusive)
type monadic reveal type of x. -1 unknown; 0 nil; 1 []; 2 integer; 3 string; 4 char; 5 symbol; 6 float; 7 dict; 8 vector; 9 builtin; 10 reference; 11 void; 12 nilad; 13 monad; 14 dyad; 15 triad; 16 verb.
exit monadic exit with code x.
time monadic yield current timestamp.
succ monadic yield x + 1.
pred monadic yield x - 1.
flat monadic flatten vector x.
fac monadic yield !x (factorial).
fib monadic yield xth fibonacci number.
fun.q monadic is x function?
hget monadic send a HTTP GET-request to the URL specified by x; yields vector: response-code;response-body; if x is symbol, http-scheme will be appended.
repr monadic represent x as a string. e.g. repr 1 2 3 yields "1;2,3"
input monadic print prompt x and read input string from input, pass empty symbol to disable the prompt.
use monadic read and eval code from file x or load an external shared library.
get monadic read file x.
line monadic read single line from file x.
close monadic close file x.
slurp monadic read file contents by filename x.
open dyadic open file x in mode y (r, w or both).
put dyadic write string y to file x.
save dyadic write y to file by filename x.
add dyadic append string y to file x.
in dyadic is vector y contains x?
split dyadic split vector y by index x.
shape dyadic reshape vector y to shape specified by x.
ltrim dyadic strip substring y from left side of string x.
rtrim dyadic strip substring y from right side of string x.
trim dyadic strip substring y from both sides of string x.
do dyadic if x is integer: execute function y x times; if x is function: execute function y while x evaluates to true.
rotate dyadic rotate vector y by x.
explode dyadic split string x by string y.
cut dyadic split string x by regex y.
join dyadic join string x by string y.
filter dyadic filter vector y with predicate x.
date dyadic format timestamp y to format x.
getc niladic read a character from input.
args atom list of command line arguments.
stdin atom standard input port.
stdout atom standard output port.
stderr atom standard error output port.
va.v atom version of the interpreter.
va.vn atom version number of the interpreter.
va.b atom build of the interpreter.
va.h atom host-system of the interpreter: win64; win32; osx; linux; unix; posix
pi atom π number
tau atom τ number
e atom e number


Valib

Valib allows to write native libraries for Valkyrja in the C language.
Sample:

// lib.c

#include "vae.h"

FUNDEF(add)
  if (type(x) == NUM_T && type(y) == NUM_T)
    return mknum(fromnum(x) + fromnum(y));
  else if (type(x) == INT_T && type(y) == INT_T)
    return mkint(fromint(x) + fromint(y));
  else ERROR("type error");
}

Value _pi15;

VARSET(pi15, _pi15);

INIT {
  // Called before library is initialized.
  _pi15 = mknum(3.1415 / 1.5);
}

EXPORT(2) {
  FUN("add", DYAD, add),
  VAR("pi1.5", pi15)
};

Compiling:
$ cc -shared -fPIC lib.c -o lib.so
Using:
    use`lib
2
    add(1;2)
3
    add(1.;1.5)
2.5
    add(1;1.5)
|type error
|   add
    pi1.5
2.09433333333333