Animo Language
Animo is languge created on the border of linguistic, 
neuroscience, algebra and xml database. 
It's declarative representation of information relations
and processing agreements.
RDF, SPARQL, OWL, XQuery, XSL and XML Database are well known technologies, but there is no single glue to put all this together. The main advantage of these formats is flexibility.  However, that leads to many different representations of same structures (e.g DocBook, TEI and etc). The problem of complexity is similar to C libraries, in that we must operate at the level of the data structures. After C, came Java with its standard libraries, a language which programmers can use 
and which can be easily understood by other programmer. The Animo language aim to create universal language for people (not only programmers)to speak.

Each time we start new project, we have to choose which technologies we should use, and how to put them all together. We are also concerned with separating data from code, and constructing tests to assert the behaviour.

Animo solves these issues and much more. With Animo, at design time your are not forced, for example, to have to choose top-down or bottom-up processing, it can be controlled by instructions.Default evaluation strategy similar to LISP. The Animo language cover PROLOG's  use cases.

The language incorporates many proven features whilst also incorporating some new ideas, with the aim of making programming more natural for humans. The eventual goal is to create a bridge between native languages and Animo structures, computer programming style should evolve to become a dialog with the computer and as such dialog constructs must be a part of the language itself. Currently the language constructions are based on English-Prime concepts, so you can write your code as through writting a book or specification.
Integrated database space as the global context for language processing.
Processing flow and Context mix-in
IS-HAVE relations build into the data model
Data and code merged into one model
Pluggable architecture: data, models, code and languages (evaluation of different    languages)
Type safe reference resolving
Animo language injections to XQuery, XSL and others
Features:
There are numerous differing languages, but each share common ideas:
Processor operation is directly mapped to language operator;
Stability of processing line (order of calculations [and-structure]);
References (variables or functions);
Conditional forking of processing-flow (binary [if-then-else] or multi [case statements or pattern matching]);
Multitasking (parallel calculations [or-structure]);

The Animo language is different because:
All information resides in one reference space - “context” & dynamic language processing model. [Language evaluation model is merged with language processing model] This hides function parameters, but does not remove them completely (hide it into the function's code). Keeps the possibility of static analysis to resolve “dead” references (variables).
Merging code and data into one topological space. This has some interesting effects:
The processing line for same input can be different, because of feedback effect.
“Separating line” moving from data-code to more–less stable structures.
Additionally, simultaneously, it's possible to optimize (cache) calculations to speed-up processing in general.
Merging code and data
into one topological space
Relations between context and processing flow
Processing model
The processing model is base on ideas taken from nervous system and
has axioms:
Axiom 1: Cell's life (including neuron) can be described by R = F ( C ) (1) where F – function (flow), C – environment force to cell and R -  cell force to environment
Axiom 2: Group of cells' life (including neuron) can be described by (1) Axiom 3: Neuron or neuron's structure choose processing flow base on input signal (pattern detection)
Axiom 4: Neuron's structure can generate dynamic (depend on incoming signal pattern) or constant signal (signal will not changer over lifetime).

Neural circuit always have input, output and processing path. This can be simulated by two different processing models: “from inputs to outputs” (FIO) or “from outputs to inputs” (FOI). Both of them are equal on result, but different on optimization needs and opportunities. Processing optimization for single output is better with FOI model, but best result can be achieve by balancing it with FIO model.

The request processing:
[input]→ sense functions → (context, processing flow) → processing flow (context) → [output] where sense function detect input information and transform it into processing flow and context.
local is the context with the highest priority;
stack is context's train. The evaluation result pushes the local context to stack;
global context is the documents stored in the XML database;
flow context is the processing line until current position.

During evaluation context can be transformed to processing flow, or added to context. Result of the evaluation is sent to context.
Evaluation contexts
The processing flow element has
access to several contexts:
local, stack, global and flow
The Animo processing flow tree
Example
Processing flow
Context
Go to sense function
The root-servive prefer
the root-layout
as HTML template.
This service will create
a HTML page.
From a content of
any root-service prefered
by context
From content of this root service
will be created a HTML
Html will be created
with any layout
And will use any theme,
prefered by context
The site context use the
"uuid-c97fd56c-ae81-493a-a508-6fbb8f4b12dc"
as root-service
The site context use the
theme "conrete"
This theme prefer the next
layout for root service
Layout use extract
title and content
HTML will be composed here
with service content transformed
by layout
Result will be searealized
as HTML
Via XQuery
In result
we will have
Or
Depended form used
service, theme or (and) layout
More screenshots
of form's generator
and map service
The end