TermSurf is a theoretically decentralized organization that is run by a decentralized group of individuals. The organization works on simplifying models of reality, and creating a narrative to describe and share how reality works, so that one may master their life and experience, and relationship to the whole.
TermSurf is an open community of people interested in exploring the possibilities with an open mind and open heart. We listen to everyone's perspective and communicate directly to what is being said, so that we can together move forward in conversation and not get stuck battling each other over meaningless stuff. We do our best to make logical links between statements in a conversation, even if the formal model takes some hypothetical assumptions for granted, so as to make all of the models consistent throughout. We don't assume we know everything without showing the logical links we used to get to what we are discussing.
If this sounds like something you are interested in exploring, something that you already do to some degree because it's your thing, reach out to base@term.surf and we will add you to the list.
The Seed is a database of models, written as notes, semi-formal documents, and code, in Tune and English. It is a summation of the knowledge found across many ancient texts and knowledge traditions. The seed repo is for having discussions on seed, and storing the final models and notes into a book and website content.
The Nest is a collection of books and stories, which talk about the seed, and share information about the history of the universe in narrative form. It comes from the perspective of a chain of early humans from the stone-age past until today in an unbroken chain.
- We seek to have an open mind. We embrace all perspectives with an open mind, and explore to try and find the logic behind all beliefs and statements.
- We seek to be an open, transparent, and decentralized structure.
- We seek to share all our knowledge for the benefit of humanity and the universe, not keep it hidden or locked away for only a special few to know about.
- We seek to explore, innovate, create, solve problems and give back to the world to try and bring less pain and more peace, happiness, and understanding to the world.
- We seek to be compassionate, kind, and understanding to all humans, things, and the universe as a whole.
- We seek to discover the hidden depths and meanings in the universe, and to not stop until the universe is fully comprehended in a simple enough way for anyone to understand.
- We seek to enjoy life and the universe, to live a free life the way we want, where we can live how we'd like, assuming it is not causing anyone else harm, and can have privacy if we'd like, or have fame, whichever paths we choose should be possible to attain.
- We seek to be a benefit to the world, in whatever shape or form, without feeling pressure to live up to unattainable ideals.
Welcome to TermSurf's page, focusing on a few main things:
- software: Open source software experimentation is the passion project.
- knowledge: Understanding how the universe works and modeling information is the main drive.
- language: Modeling things in natural language or code gives a deeper sense of reality.
- story: Sharing learnings in the form of stories or philosophical conversations.
TermSurf is basically trying to synthesize and simplify the knowledge of the world so it boils down to something you could hold in your hand. Something where you can have a wide and at the same time deep sense of how the universe works.
The projects by TermSurf are for unrolling the carpet of these "come-across" patterns and processes for everyone to see and gain a whole new awareness about reality. Together as a team we can slowly find a whole array of patterns of various types and kinds, but for now we have just experienced a few of them so far, and wanted to share the notes in the form of various web projects.
The tools range from a language system involving the programming framework Nest, on top of the source code written in TreeCode, to a writing system Tone, using simple reflections and tails on 3 base glyphs generated from 3 base vowels, to write, using a pen or a rock etch, our spoken language, or the programming language. And a spoken language Tune to bridge the gap between computational information and natural imagination. They also include some digital tools to make life better and explore the patterns more intricately, such as natural language dictionaries, musical tracks, common reusable data, and other important things for preserving the knowledge (in concise form) of what we have unraveled so far up to today.
| Tool | Note |
|---|---|
tone.surf |
Tone: A Cross-Cultural Writing System |
| A simplified and uniform writing system for all the languages of Earth. | |
tune.surf |
Tune: An Intermediate Constructed Language |
| A natural language used to model and play with reality in a deeper way. | |
tree.surf |
TreeCode: A Data Modeling Language |
| A "modeling language" where you write in concise and minimalistic trees of text. |
The goal is to create a seed for transforming consciousness into a beautiful new flower. The seed will likely for now be some sort of evolving book or world or game which you engage in to gather the knowledge. Books would be an easier MVP, but utlimately who knows where things could go.
TermSurf is creating a next generation data modeling framework, and APIs for the emerging group of digital natives coming into the work world full force. It's the hope that the designs and blueprints outlined in detail here will be implemented in the coming years. With all your help, and the help of AI in the time ahead, we will bring these interfaces to life, and they will make it super clean and straightforward to define patterns, structure data, and write reusable, shareable code.
The main passion project is to have one programming language or tool to build all possibilities of software apps and libraries. Something like Rails, where everything is streamlined and out of the way so you can focus on your main task instead of wrangling code. Combined with something like Haxe or Dart where it compiles down to every platform natively. We are deep into the programming and computer science worlds, having been working toward this goal for several years. There's still a huge amount of work that remains to be done, and like mentioned earlier, the look and feel of everything is still being defined at this point, only barely scratching the surface in terms of making the code run.
There is tree, a super minimal tree-based data modeling language sort of like YAML/JSON/XML, which is in some ways more readable and concise than them. That project is basically finished. The spec is defined in that repo, and a primitive parser is implemented to convert link text into a tree. The next step is taking the link tree and compiling it into runnable code via term.tree.
The goal here is to create a suite of tools to write code in one language, Link, and have it work cross-platform in an optimized way. This means compiling the TreeCode into Swift for iOS/MacOS/etc., Rust for Linux server-side, Kotlin for Android, and JavaScript for Windows, the Browser, and Node.js. But many of the projects are written in such a way as to be language agnostic. That is, you can use the definitions, which are written in tree, as you would any JSON object in your standard programming language.
Once we can nail down a prototype implementation that works in at least JavaScript (Node.js and Browser), and either Swift or Rust, then we will start publicizing the results and asking for help. But currently things are fluctuating constantly so it might be too much to bring it out in the open (even though it's publicly open source). If you'd like to help though, even now, that would be totally wonderful, please reach out.
The following table outlines the key projects and their overall purpose, so you can see how the pieces of the puzzle fit together. This is mostly a love for learning, a journey to understand the fundamentals of building an optimized compiler.
| Code | Note |
|---|---|
tree |
The Data Modeling Programming Language |
This is the "data modeling programming language" which term.tree extends into a programming language and environment. There's not much too this piece other than the syntax. |
|
term.tree |
TermTree: A Programming Framework for TreeCode |
This is one example tool for building tree programs. It is a TreeCode package manager, as well as its compiler. |
|
bind.tree |
The TermTree Platform Binding Library |
| This is a library of all the native types for each programming language / environment (JavaScript, Swift, Rust, Kotlin). This gives us the information necessary to compile TreeCode down to native code in each environment. | |
base.tree |
The TermTree Standard Library |
| This is the foundational standard library. It includes all your standard primitive data types, as well as other well-defined data models which are useful in standard apps. It implements these in Node.js, the Browser, Rust (Linux server-side), Swift, and Kotlin (down the road). | |
deck.tree |
The TermTree Package Manager Library |
| This is the package manager, which fetches and knows how to find any file necessary for the compiler. | |
make.tree |
The TermTree Compiler Library |
| This is the compiler, which takes the TreeCode AST and transforms it into an AST based on your structure definitions, and then does the typechecking and typeinference and such to verify its correctness statically. Then it generates the JS or other target language output. | |
flow.tree |
The TermTree Runtime Library |
| This is the runtime library, which encodes the necessary base logic to hold the packages, files, data, and code in one unified place. | |
view.tree |
The TermTree Graphics Library |
| This is eventually going to be the UI library, encompassing what React.js does, and what graphics engines do, and also handling other graphics related stuff. | |
link.tree |
The TermTree Third-Party API Integration Library |
This is a collection of REST (and potentially other) API endpoints, written in tree. It is going to be used to provide integration with many services in the term.tree / tree ecosystem, though it is written in a language-agnostic way (i.e. you could use this in any language). |
|
code.tree |
The TermTree Content Grammar Library |
This is a collection of "grammars", written in tree. These are pattern recognizers for generating object structures out of text or binary strings, and doing the reverse, of generating text/binaries from objects. They are defined in a language agnostic way. |
|
form.tree |
The TermTree Math Library |
This is a collection of mathematical formalizations, written in tree. These are going to be used, following along the lines of the HoTT project, as a foundational model of mathematics for use in a programming environment. |
We are just beginning, so much work is being done on the specifications, with only rough prototype implementations to test out the specifications. Once we finish the specifications and base implementations, it should be a usable cross-platform environment. Please reach out to use by opening an issue in any of the projects or finding us on Twitter if you'd like to discuss, exchange ideas, or in other ways join in the fun.
At first there was the tone script, a writing system like the ancient runes that can encode any language on Earth in a concise and readable way using simple glyphs you could either carve on a rock, make out of sticks, or draw with a pen. It is built around tones, the vowel and consonant sounds, and there are 36 base glyphs, with special markers for things like tone in Chinese, and other important features. It is instantiated into a TypeScript library so you can convert an ASCII representation into the format used by the main font, ToneEtch.
Then there was tune, a language derived from imagining an ancient stone-tool making monkey culture of the past, and evolved it into a modern language capable of representing all of modern concepts and knowledge, such as naming species and places and everything you can imagine. That is very much an evolving work-in-progress. The goal here is to create a an intermediary framework for representing knowledge, for creating a way to conjure up "fantasy" words so we can name things which don't have names, to explore new concepts and ways of thinking.
The project Tune is an attempt to create an evolutionary pathway for discovering spoken language in the same way. It moves you through a hand selected network of paths to a plausible description of how modern language got into existence. Tune is to tune yourself to the universe, which is what one does, through meditation and introspection, to align yourself with the oneness of the universe. To go with the flow.
The model for language is the Flow. The flow is any sequence of sounds which provide some structure to a unified concept represented using sounds. So in this sense flows are nested. Flows combine into other flows.