its really mindblowing to see how wide-ranging the needs of people are concerning a timeline. sounds like there can’t be just one being suitable for everyone.

for example, i just need plain animation and don’t care about recording, live inputs, midi mapping, asset management and so on.

therefore its good to see different approaches in the SOD

so my only suggestions for kairo would be:

  • intuitve UI, with everything one would expect from a modern UI
  • low cpu hit

regarding other softwares - I’m working with Ventuz a lot for the last two years, it’s Animation node is a state machine with timeline, and is a pleasure to use.
Might be a good study material, the software can be downloaded and tried for free.


Thanks guys for all these precious inputs.

As u7angel said, it’s really incredible to see how many needs and whishes related a timeline. It’s clear that is a key piece of software… :)

My intent is to first release a relatively simple tool, which will have all the functionalities of a basic timeline (as the old Timeliner node) plus the new feature of “dynamic keyframes”. These dynamic keyframes are for me the most innovative contribution of this research and I’d like to have as soon as possible some feedbacks from the community.
Then it will be a long journey to evolve this first version of Kairos.Timeline into something else, more rich and versatile. Actually, my final goal is to get something like an Ableton Live kind of software, but incredibly superior in terms of realtime contents management. This will be Kairos.

So, coming back to the roadmap (also a reply to @readme) , this first version will come as a “centralized” editor, in which you create tracks, group them, add and edit keyframes, and so on…
then there will be a set of nodes to set and retrieve data from it, like: GetTrack, SendChannel (to send any kind of data to a channel, received for example by a dynamic keyframe), SetKeyframe, SetCustomClock, …
I’ll probably also pack some of the Kairos.Timeline features as independent vvvv nodes, eg. a Track node, which contains all the features of a single track without the rest of kairos. this module would still allow you to create amazing gradients and fades…
obviously you can still instantiate many Kairos.Timelines as individual vvvv nodes, even if not best optimized approach.

few scattered replies to your suggestions:


  1. not in the first release, but def wanted
  2. already now the runtime of the software is separated from the model and the editor, so it will be possible, i guess, to have some sort of independency from the vvvv fluctuating frame rate.
  3. yes. It will be possible to record keyframes on the fly. I’m still thinking to a different mode in which you can record raw values, with less functionalities than keyframes but better performances.
  4. and yes, editable keyframes.
  5. this is totally possible (I also need it for NRT rendering). Since you can manually set the Time 64bit value (which is the position of the sampler that sample each track) you can read from the timeline as you like, eg. sending the time position of every frame from your vvvv patch…
  6. right now I implemented just Time (in seconds) as the main time measurement. I already got a dynamic snap to quantize movements depending on the time zoom magnitude.
  7. My plan is to put a toggle to switch between Time and Tempo (with BPM and Tempo Signature).
  8. I definitively want to have hierarchies in tracks. I’m still thinking (and I’d like your suggestions) what kind of control you would have over tracks from the group level, and how to display groups in UI.


  1. I already have this feature as “section markers”, which have a dedicated mini track under the time bar.
    you can play from any of the section markers and even call from outside (eg. vvvv node).
    what’s best: “section” or “chapter”?
  2. sorry my ignorance, what’s OTF?
  3. regarding frame interpolation:
  • It will be per keyframe
  • types: StepIn, StepOut, Tween (with all relative settings), bezier (being able to control two handles)
  • advanced SpreadCount interpolation modes
  1. I’m still considering all this merging stuff… def not in this first version
  2. do you mean sort of labels that you can put into the timeline of every track? like comments that you can place near the keyframes?

…chaos is my bread… :)


  1. to 5. will see how much i can get in terms of external control for this first version, but definitively wanted.
    I’d like to have Audio tracks in the future, don’t think in this first release.
    Regarding GUI:
    I already splitted completely the model+runtime part of the software from the editor (UI), so you can eventually edit the timeline then have just a much light player without any UI… …or design a minimal interface.


  • nesting feature def is the direction of kairos. not for this first release
  • serialization: I’ll def want to sort this part in a way that future version will be campatible with previous presets and scenes. so yes, I need to create a standard for this.

thanks for the link!

keyframes snapping to other keyframes: yes

you will get an animation tool already from the first version… …hopefully :)

thanks so much for the input. I’m downloading it and I’ll def give a try. tnx

I’ll keep you posted with the development news and I’ll ask here if I have doubts regarding some features
thanks to all


…and don’t stop to send me suggestions and links for references ;)

1 Like

I was shamelessly using a DVD term! Being a (time)line it should be nor chapter or section, but segment, no?

on the fly

Yes, I see I wrote point; that should have been keyframe obviously. Then, great and greater.

Merging logic would be very important, because it would let you sync keyframes and segments (I’m already calling it like this) and making many of the other requests, which I respectfully consider not part of a *barebone timeline, more easy to be integrated as external plug-ins, or modules if you like. It would allow complex animations with much less effort than now.
I understand that this should be more a reminder about keeping it in mind while building the timeline, than an actual request.

*barebone = including all that logic and operations and… required to manage values along time in the most flexible way.

Yup, something like that. Complex animations would need many details and cross-referencing: having the chance to put a note that says “recalculate this based on new data” or “sync with segment XYZ” would be immensely helpful.

Oh, dear, do you want some thread, with your bread?
No granny ever


what about the ui? will it be rendered by a vvvv dx11 renderer or are u working on your own window + optimized rendering ?

if not, this would a be request too, kairo should be just one node without the overhead of vvvv patch + vl patch since i guess this is eating cpu cycles for breakfest, no ?

I’m currently developing the ui using craftlie library. It seems quite light and avoids too much vvvv patching.
for now is fine, but the plan is obviously to be independent from vvvv.

Hello guys,
Quite a long time passed from my last words regarding Kairos, so let me update you about what’s going on.

The latest concepts and ideas I shared with you (at node and in the post) were mostly regarding a timeline tool that had this new feature of dynamic keyframes.
Obviously during summer development many things changed.
I’ve been in Berlin in august, for a development session dedicated to kairos.
Devvvvs were just great and fully supportive. together we dig into the software I had in mind, trying to abstract things and finding the strong principles to look for.

From the very beginning I realized that the software I had in mind wasn’t just a timeline.
Due to the fact that I urgently need the software for production, I changed plans and, instead of going for a timeline tool, I prioritized the development of another mode of kairos: the Matrix.

You can think at this Matrix mode as the Session View of ableton live. it’s basically the same thing.
Each parameter controlled with kairos is a column of the matrix (“channels” in ableton).
the rows represent some sort of “scenes”.
Each matrix cell contains a state (static or dynamic) of that parameter.
you can then click on a cell and trigger live its state, exactly like triggering the audio/midi clips in the ableton session view.
I decided to prioritize this Matrix mode because is the simplest way to define-design the state (scene/preset) of an entire parametric system. A preset is a row of the matrix, meaning a cell, empty or not, for each kairos parameter (column).
A timeline is already something more: it’s a way to organize over time different states (-scenes-presets) of a parameter.

In kairos the state of a parameter is define by a DataSource.
DataSources are the building blocks of your Kairos scene (eg. you may put DataSources into the Matrix cells).
A DataSource can be of different types:

  • Static
    It’s a static value for the parameter. It can be anything: a value, a spread of values, a color palette, etc…
    Every data you can imagine which is static, stored in memory, not dynamically generated.
    obviously there will be an editor to design each Static DataSource

  • Dynamic
    Any State that is dynamically generated. eg:

  • LFO (obvs in a spreadable fashion)
  • Perlin
  • Random
  • Audio Analysis
  • Kinect Data
  • Particle System

  • Each Dynamic DataSource will have it’s own control UI, sort of inspektor, like the ctrl window of VST plugins (distort/reverb/…) in the sound editing softwares.
  • Filter
    A DataSource can take another DataSource Output as input, manipulate it and return it transformed. These kind of DataSources can be called Filters. eg.
  • Linear Filter
  • Damper
  • Oscillator
  • Levin
  • Delay
  • Container
    Containers are very interesting DataSources: thet take a set of DataSources as Input plus a Model, a set of settings (specific for every container) that tells the container how to handle the incoming DataSources.
    If you abstract enough, you can basically see most of the features of an advanced software like Ableton Live as a collection of Containers:
    let’s take the timeline.
    timeline container takes a Model that describes the keyframes position and all their settings (interpolation, dynamic/static, …). Then it takes also a spread of DataSources which might be the Dynamic DataSources available in the system that will be assigned to some dynamic keyframes.
    The timeline container then has some functionalities to handle these contents, like some interpolation functions.
    It takes the incoming dynamic DataSources. dispatch them to the assigned dynamic keyframes, then apply the interpolation between the relevant keyframes in order to give the final sample value.
    Conceiving the Timeline as a DataSource (Container) allows to use it anywhere in kairos as you would do with any other DataSource (static value, an LFO, a SoundAnalysis value,…). You can put it into a Cell of the matrix, or even in a keyframe of another timeline (in this case it would become a clip, that you could instantiate as many times as you like).
    I’ve got already a list of Containers that I’ll develop in the next future:
  • Sampler 1D (Timeline)
  • Sampler 2D-3D-… (Delaunay Sampling)
  • Distance Field 1D-2D-3d-… (distance based sampling)
  • Switcher (like a multiFlipFlop)
  • Automata
  • StepSequencer
  • Patcher

By abstracting the software to this level it’s much easier to think at it in a modular way.
Another example is the matrix itself:
Each column can be seen as a Switcher Container in which you choose between different options (cells) to set the state of the parameter assigned to that column (multiFlipFlop behaviour that controls a Switch).

To achieve this kind of freedom, in which you are able to create DataSources, place them anywhere, enchain them, nest one into each other, and so on… a really simple, flexible but robust interface was needed.
@gregsn and @Elias did a great job in building a c# interface that we then implemented in vl.
This interface allows to patch some functionalities that are wrapped as Nodes, with Input and Outputs.
These nodes behave following a Pull model, like the nodes and patches in vvvv.
This means that if you don’t ask for their output value from bottom, they don’t get evaluated.
You are able to create DataSources on runtime, registering them into an engine, making them immediately available for other DataSources to be used.
Basically, this system makes the user a meta-patcher, able to create nodes and connect them in runtime without recompiling.
This is great. This is already in place.

Another aspect that I started to look at together with devvvvs is the UI.
I didn’t want to spend time in building a “static” UI for Kairos (Such a boooooring thing… hihihi), specially after focusing so much on modularization at all levels of the software.
Since the topic is very appealing for the vvvv/vl community in general, we set down at devvvvs place thinking to a nice way to achieve a good multi purpose modular UI library.
And @tonfilm kicked in, as you probably noticed from his post.
This is certainly a good opportunity for all of you to contribute to kairos development and, in general, to the development of a super cool and handy UI editor library.
I started creating some of the basic UI elements (like slider, Toggle/Push/Bang buttons, multiButtons, …) but we need to add many more.
You are welcome to partecipate!

So, at the end of this biblical post,
I’m sorry to disappoint those of you who were just waiting for a timeline tool in september. It simply won’t happen. :)
What is already happening it’s way more than a timeliner. it’s a flexible system that allows to manage realtime data in a nice new way.
Trust me, the wait is worth ;)
For all of you that offered support in development, I would love an hand on the UI part, as I said previously in the post. Let’s push it forward!




Thanks for the update! It really does sound worth the wait,

Hello guys,
never say never… …a new kairos report :)
waiting for your feedbacks and suggestions.



Sorry for the late entrance but I just now discovered this blessed initiative!
I recently stumbled upon this very nice timeline software and found it very original and inspiring. https://ossia.io/
Its kind of a condition based timeline…
Anyway, perhaps I totally beside the point… I am allready in love with Kairos!!!


Hey @ofersmi, thanks so much for the link!
Didn’t have time to dig deep into it but so far this ossia software looks very interesting.
I feel it’s full of cool concept and ideas.
thanks again for the input ;)


1 Like

super awesome kairos and great videos.

thanks and congrats to vl and dottore,s initiative. very impressive ¡¡

This topic was automatically closed 365 days after the last reply. New replies are no longer allowed.

Wow, it was a long journey…
but here we are! 3 years later…
…and we have an official release of Kairos, now available as nuget for vvvv gamma!
here you find an excerpt of the presentation at the last vvvv meetup:

I opensourced the project, you can find it on github:

Kairos is now freely available for any non-commercial use.
To maintain the development i trust commercial users to contribute to the project paying a licence, so that we can keep it evolving for the interest of all.
For licencing this is the contact email: natan.sinigaglia@gmail.com

So what’s next?
Well, I’m currently working at the release of Kairos 1.0 which will be the solid base for further expansion of the software.
My Hope is to release it in the next couple of weeks

…just in time for the first KAIROS WORKSHOP!!!
yes, yes, it’s happening. :)
hosted by the Node institute, this is the page where you can subscribe:

I hope to see you there numerous!!!

For now is all.
I’ll keep posting here more frequent updates from now on.
all the best



Kairos development camp 1.0


Dear vvvv people,

I am thrilled to announce that the time in which kairos development is ready to take off as a collective endevour, is finally here!
As I mentioned in the last meetup, the past year I’ve been working (on and off) on rewriting kairos. Multiple reasons forced me into this endeavour:

As Kairos is a framework for data control, so generic and vast, it will require maintainance, research and development. As my goal has always been to create an opensource project which grows with the shared effort of the community that takes advantage of it, I had to first ensure that both at the concept and the implementation level, the foundation of the library is accesible and clear. This would allow anyone interested in contributing to approach the library and easily understand how to participate in its development.

We have finally reached this point.
I welcome you into the kairos world, which is at an initial stage, but ready to quickly blossom.
My wish is to arrive with some kairos composition tools (Timeline, Compositor, Matrix, PresetConsole, …) at an advanced stage, fully ready for production by Christmas 2022. I’m confident in saying that this is an achieveable goal if we join forces!

Therefore I would like to invite you to a “kairos intense development camp”, which will last 5 days, from 12th to 16th September 2022 in Berlin. The plan is as follows:

  • I introduce you to the kairos concepts, going deep into every aspect of the library from a theoretical point of view.
  • We have a look at the current implementation of all the components that constitute the library.
  • Once we have a grasp of concepts and their implementation, we brainstorm around these to familiarize and imagine user scenarios.
  • We isolate topics, define priorities and make a global roadmap.
  • Either in small groups or all together, we assign tasks and and start working on them.
  • At the beginning and at the end of the day (or spontaneously if an extra need arises) we have open sessions where we share achievements and issues.
  • At the end of the camp, we dedicate a session to sum up the results and plan the remote development over the next months.

I would like to underline that this is not a kairos workshop for final users; it is focused on development.
For this reason, even if the topic interests a lot of users in the community, the camp is addressed to people with a medium-advanced knowledge in vl/c# and object-oriented programming; preferred but not necessary some experience in writing libraries, systems and softwares.
Although presence is highly recommended for productivity reasons, for those extremely interested in participating, who aren’t able to physically attend, there may be the possibility of a continuous streaming option, to allow them to join the workshop (pls write a note about this in the shared spreadsheet below).
In the attempt to keep the camp as open as possible, we will try to publicly stream all the parts which could be relevant for people outside the camp (eg. the theoretical introduction to kairos, creative brainstormings and recap sessions).

The devvvvs kindly offered a space in Praxis for us to sit down at the round (Squared) table and start this adventure as Kairos knights.
It will be a great opportunity to hang out, share some vl knowledge, enjoy meals together and late summer Berlin evenings.

Karos development camp 01

from 12th to 16th September 2022, 10 am to …open.

Praxis (vvvv developers headquarter)
Oranienstrasse 10, 10997, Berlin

If you are interested in participating, pls add yourself to the list in this shared spreadsheet:

Looking forward to it!




I will be of no use to you at the camp, but I will sit at home and cheer and send all the best energy and karma.


I sadly can’t support directly in that time period, would have loved to be involved.

I have a humble suggestion though: would you consider preparing real life usecase project(s) to target solutions to in this week?

Could be a project from the past with real data.
Or you could ask the community to come up with one based on their pain points with existing solutions.

I think this could help ensure strong practical usability focus of new features.


Hey @tobyk, sorry to hear you won’t make it this time. It will be for the next kairos camp!

Tnx for the suggestion. 5 days of work won’t probably be enough to give solutions to users problems, but having the final user perspective over things helps tremendously in keeping a grip over priorities and needs.

We could imagine having a dedicated Zoom call where users from the community can show their case scenarios.
I would suggest having this open zoom call on Monday 12th at 19:00 CET, after my introduction to kairos theory and implementation. …Once the camp developers have a better understanding of the library it might be easier to approach scenarios and find solutions.

I’ll add this open call to the agenda and also add a section in the spreadsheet where anyone can book a slot of 10 minutes to talk about her/his usecases.



To facilitate planning the activities, I added a Sheet “Detailed Availability” to the kairos camp spreadsheet.
Pls check in there, so I have a rough idea of what to do and when. cheers