Welcome to Reykunyu! Reykunyu is a user-friendly online Na'vi dictionary, supporting translations to and from English, German, French, and other languages.
Reykunyu is Na’vi for "someone who causes (you) to find (something)". Search for reykun and -yu for more information! (Note for Na’vi experts: -yu is not productive with ‹eyk›, so this usage is technically non-productive. Reykunyu is a name though, so anything goes.)
Interested in learning Na’vi?
A dictionary like Reykunyu is great for reference, but not necessarily useful to actually study the language. For proper learning materials (grammar guides, lessons, word lists for beginners, etc.) please visit one of the websites dedicated to learning Na’vi: Kelutral or Learn Na’vi.
Looking up words
To look up a word, go to Reykunyu's main page, type the word you're looking for into the search box, and press Enter. Make sure the dropdown to the right of or below the search box is set to Na'vi ↔ English (this is the default):
You can either input a Na'vi word to find its English translation, or you can input a word in English to find Na'vi words with your searched word in their definition. (If you want to search in another language, then use the language selector in the top-right.) Reykunyu tries to guess which of the two search directions you wanted, but if necessary, you can switch between them with the Na'vi → English and English → Na'vi tabs that appear under the search box after you made a search:
The small numbers on the tabs indicate how many results there are for the corresponding search direction.
Na’vi → English searches
When you input a Na’vi word, Reykunyu is quite good at detecting affixes. You should be able to search for almost any affixed form. Reykunyu will figure out what affixes your word has, and show you its dictionary form plus a list of affixes that were present in your word. Reykunyu also does its best to figure out what you meant if your word has incorrectly applied affixes. In this case, it will also show you what would have been the correct affixed form. Additionally, you can search for more than one word at a time, in which case Reykunyu will display a list of separate words, looking something like this:
Click on a word to see the results for that word. As you can see, Reykunyu automatically detects phrases and si-verbs, and treats them as a single word.
English → Na’vi searches
When you input an English word, make sure to only input one word at a time, and input it in its dictionary form (for example, "want", not "wanted"). Reykunyu doesn't know English grammar rules, and doesn't understand that "wanted" is just a form of "want". So searching for "wanted" won't give useful results.
Results
Word types
Reykunyu shows for each word which type of word it is. It uses the following abbreviations:
| n. |
noun |
| npr. |
proper name |
| pn. |
pronoun |
| adj. |
adjective |
| num. |
numeral |
| adv. |
adverb |
| adp. |
adposition |
| adp+ |
leniting adposition |
| intj. |
interjection |
| part. |
particle |
| conj. |
conjunction |
| sbd. |
subordinator ("F-word") |
| vin. |
intransitive verb |
| vtr. |
transitive verb |
| vm. |
modal verb |
| vcp. |
copula verb |
| inter. |
interrogative |
| pref. |
prefix |
| inf. |
infix |
| suff. |
suffix |
| phr. |
phrase |
Other search modes
Besides the default Na'vi ↔ English mode, Reykunyu offers two other search modes that you can select using the dropdown in the search box.
The Annotated Dictionary mode allows you to search in the Annotated Dictionary by Stefan G. Müller. This dictionary contains, besides the definitions for the Na’vi words, a large number of usage examples and clarifications. Reykunyu contains the exact same data as the Annotated Dictionary PDF file. Note that Reykunyu won't find affixed forms in this mode.
The Rhymes mode is a simple rhyme dictionary. It allows you to find rhyme words, grouped by number of syllables and the stressed syllable. This is useful mostly when writing poetry.
Reykunyu was created by Wllìm, but would not have been possible without the help of the following community members and other people.
Irayo nìtxan ma frapo!
Dictionary data
The base dictionary data was taken from Eana Eltu by Mark Miller, Tirea Aean, and others, and then edited further by Eana Unil, Tekre, and Wllìm. The Annotated Dictionary definitions were taken from the Annotated Dictionary project by Plumps.
Audio
The voice clips were provided by Plumps (who recorded them for dict-na'vi) and tsyili (who recorded them for Learn Na'vi).
Artwork
The drawings of Pandoran animals were made by Eana Unil. (Haven’t encountered one yet? Try searching for ‘toruk’!) Reykunyu’s logo was drawn by Eana Unil, and the calligraphy in the header was made by Nahura.
Libraries
Reykunyu uses jQuery and Semantic UI for the frontend, and Node.js for the backend.
Source code and data
Reykunyu is licensed under the GPLv3, and the source code can be found on GitHub. The main dictionary data (which you can get in JSON form here – see also the API documentation) is licensed under CC-BY-SA-NC 3.0. This excludes the Annotated Dictionary data, the audio files, and the animal drawings; these are copyrighted by their respective authors.
Reykunyu has a JSON-based API that can be used to do searches programmatically. The API is useful if you are a developer and you'd like to integrate Na’vi searches in your website or app.
The API is free to use: there are no API keys and no (formal) usage limitations. Please don't abuse the server though; I reserve the right to cut users off the API if their usage disproportionately impacts server resources. (This has never happened before and I don't expect it to happen anytime soon: it's not like the Na’vi language is a super popular target for app developers …) On the other hand, Reykunyu doesn't make guarantees regarding uptime and compatibility: the API may sometimes change.
Fun fact: Reykunyu's website itself uses the same API for its searches, so any data you can see on the website can be retrieved using the API too.
/api/fwew-search GET
The main endpoint for searching. This is the same endpoint that gets called when you search via the web interface.
Response
| fromNa'vi |
Results of searching for query in Na’vi.
Reykunyu splits the query into separate Na’vi “words” and returns results for each of them in an array. If Reykunyu detects a si-verb or multi-word phrase in the query, it is counted as one “word”. For each “word”, the following is returned:
| tìpawm |
The part of your query that makes up this “word”. |
| sì'eyng |
The results for this “word”, as an array of WordData. |
| aysämok |
If there are no results, an array of suggestions (to be used to implement “did you mean …?” functionality). |
|
| toNa'vi |
Results of searching for query in the language you specified, as an array of WordData. |
WordData
Each individual result is returned as a WordData, an object containing all information about a single Na’vi word. It has a large number of properties describing the word, most of which are optional.
| word |
The Na’vi word in question, with syllable separators (/) and stressed syllable markers ([...]). For si-verbs this does not contain si, and for affixes this does not contain the hyphen or angle brackets; see here for how to do the postprocessing.
| FN |
The word in Forest Na’vi spelling. |
| combined |
The word in Forest Na’vi spelling, but with ù marked. |
| RN |
The word in Reef Na’vi spelling. |
|
| word_raw |
Like word, but without the syllable separators and stressed syllable markers. |
| na'vi |
The Na’vi word in FN spelling.
Deprecated; equivalent to word_raw["FN"]. Before Reykunyu gained full RN support, this was the main way to access the Na’vi word. For now, this key is still provided for backwards compatibility.
|
| type |
The word type: n (noun), v:in (intransitive verb), v:tr (transitive verb), etc.; see the list here. Especially note v:si (the verb si on its own), n:si (a word that can combine with si to create a si-verb), and nv:si (the combination of an n:si and a v:si, i.e., a complete si-verb). |
| pronunciation |
A description of the pronunciation. This is an array, one for each known pronunciation of the word, containing:
| syllables |
The word in phonetic spelling, where syllables are separated by dashes and ù is indicated for RN. |
| stressed |
Integer (1-based) indicating which of the syllables in syllables is stressed. |
| audio |
An array of audio files:
| file |
Name of the audio file (you can fetch the file from /fam/<file>). |
| speaker |
Name of the speaker. Note: make sure to obtain permission of the speaker before using the audio files in an external project. |
|
| ipa |
The pronunciation expressed in IPA notation:
| FN |
IPA for Forest Na’vi. |
| RN |
IPA for Reef Na’vi. |
|
|
| translations |
An array of translations, one for each major meaning of the word (most words have just one). Each meaning is represented by an object that maps each two-letter ISO language code to the corresponding translation. |
| short_translation |
By default Reykunyu takes the part of the translation in translations until the first comma as a “short translation”. For the few words for which this isn't desirable, short_translation is used to override this (for the English translation only). |
| meaning_note |
A free-form note on the meaning or usage of the word, as a LinkString. |
| infixes |
For verbs, a description of the infix positions. The two positions are marked as dots (.) in the verb. Note one special case: zenke has its infixes indicated as z.en.(e)ke to indicate the e that shows up if certain infixes are placed in the second infix slots. |
| conjugation |
For nouns, a conjugation table, encoded as a 2D array of 4 rows (singular, dual, trial, plural) and 6 columns (the cases). Each entry is marked up in a certain way to aid coloring pre- and suffixes in the output: the part until the first dash is the plural prefix, the part from the second dash is the case suffix, and the lenited consonant (if any) is enclosed in braces (e.g., pxe-{s}oruk-it/ti).
For adjectives, the two forms with a- and -a applied:
| prefixed |
The form with a-. |
| suffixed |
The form with -a. |
|
| conjugation_note |
A free-form note on the conjugation of the word, as a LinkString. |
| conjugated |
An explanation of the infixes present in the query word. This is expressed as an array of conjugation steps needed to go from this word to the query word. We use an array because there may be more than one step. See, for example, what happens when you search for tìsluseleti: the first step makes slele into a noun, and the second step applies affixes to the noun.
Each conjugation step looks as follows:
| type |
The type of conjugation step, one of:
- n: applying affixes to a noun;
- v: applying infixes to a verb;
- adj: applying a- or -a to an adjective;
- v_to_n: applying -yu or -tswo to a verb, resulting in a noun;
- v_to_adj: applying (ke)tsuk- to a verb, resulting in an adjctive;
- v_to_part: applying ‹us› or ‹awn› to a verb, resulting in a participle;
- adj_to_adv: applying nì to an adjective, resulting in an adverb;
- gerund: applying tì + ‹us› to a verb, resulting in a gerund.
|
| conjugation |
A description of the conjugation step:
| root |
The original form of the word, before the conjugation step. |
| result |
An array of possible results of this conjugation step. There may be more than one; this contains all correct ways to apply the affixes, not only the one that results in the query word. |
| affixes |
Only for conjugation steps with n as their type: an array of 7 strings which describe the affixes placed in the 7 possible locations: [0fì-/tsa-/pe-/fra-][1me-/pxe-/ay-][2fne-]noun[3-tsyìp/-fkeyk][4-pe/-o][5-l/-t/-r/-ä/-ri/adp.][6-sì/-to]. |
| infixes |
Only for conjugation steps with v as their type: an array of 3 strings which describe the infixes placed in the pre-first, first, and second infix slots. |
| form |
Only for conjugation steps with adj as their type: either predicative (no a-/-a applied), prenoun (a- applied), or postnoun (-a applied). |
|
| affixes |
An array of affixes that was applied in this conjugation step. For each affix:
| type |
The type of affix: prefix, infix, or suffix. |
| affix |
The affix, either a string (if it is a combined infix) or a WordData (in all other cases). |
| combinedFrom |
Only if it is a combined infix: an array of WordData describing the infixes this infix was combined from. |
|
| translation |
An automatically-generated translation of the result of this conjugation step. |
|
| image |
Name of an image file illustrating the word (you can fetch the file from /ayrel/<image>). Note: make sure to obtain permission of Eana Unil before using the artwork in an external project. |
| source |
An array of sources for this word, where each source is an array of at most four elements:
| [0] |
The title of the source. |
| [1] |
An URL pointing at the source, if applicable (otherwise it can be an empty string). |
| [2] |
The date of the source, in yyyy-mm-dd format. |
| [3] |
An optional note on the content of the source. |
|
| status |
An optional status flag for this word:
- loan if it is a loanword;
- unconfirmed if the word has not been officially confirmed as correct Na’vi;
- unofficial if the word has been confirmed as a non-official word.
Note: you should make sure to clearly mark unconfirmed and unofficial words (or hide them), to avoid spreading confusion about unconfirmed words. For example, Reykunyu places this marker in the word list: unconfirmed word
|
| etymology |
An explanation of the etymology of the word, as a LinkString. |
| derived |
An array of other words (as TruncatedWordData) that are derived from this word (i.e., that refer to this word in their etymology explanation). |
| seeAlso |
An array of other words (as TruncatedWordData) that have something to do with this word (shown under "See also" in Reykunyu). |
LinkString
A LinkString is used to allow writing free-form notes that contain links to other words. A LinkString is implemented as an array whose elements can be two types of objects:
- a string, this represents plain text which is part of the note;
- a TruncatedWordData, which represents a link to another word.
TruncatedWordData
Words that refer to other words, use TruncatedWordData to do so. This is simply WordData where all fields except word, word_raw, na'vi, type, translations, and short_translation have been removed. (This is done to limit the size of API responses, and to avoid infinite loops if two words refer to each other.)
/api/fwew GET
Like /api/fwew-search, but provides only results for Na’vi words.
Response
Like
fromNa'vi above.
/api/search GET
Like /api/fwew-search, but provides only results for natural language words.
Response
Like
toNa'vi above.
/api/conjugate/verb GET
Applies infixes to a verb. The API does not validate the infixes provided, so client code has to ensure only valid infixes get passed.
Response
An array of strings, representing possible conjugations.
/api/random GET
Returns a set of random words of the given type.
Response
An array of WordData.
/api/rhymes GET
Finds rhymes of the given word.
Response
An array result of arrays of arrays of WordData, such that result[i][j] is an array of WordData containing the words with i syllables, stressed on the j-th syllable.