Telodendria

Telodendria: The terminal branches of an axon.

Note: Telodendria is under heavy development. Please see the Project Status.

Telodendria is a Matrix homeserver implementation written from scratch in ANSI C. It is designed to be lightweight and simple, yet functional. Telodendria differentiates itself from other Matrix homeserver implementations because it:

• Is written in C, a stable, low-level programming language with a long history, low build and runtime overhead, and wide compatibility.
• Is written with minimalism as a primary design goal. Whenever possible and practical, no third-party libraries are pulled in to the source code. Everything Telodendria needs is custom written. As a result, Telodendria depends only on a standard C compiler and POSIX C library to be built, both of which are built in to a good Unix-style operating system already, which means you shouldn't have to install anything extra.
• Uses a flat-file directory structure to store data instead of a database. This has a number of advantages:
  • It makes setup and maintenance much easier.
  • It allows Telodendria to run on systems with fewer resources.
  • It provides both runtime and data safety and stability. Since no database is running, there's fewer things that could go wrong because there's a lot less code running on the system.
• Is packaged as a single small, statically-linked and highly-optimized binary that can be run just about anywhere. It is designed to be extremely easy to set up and consume as few resources as possible.

Telodendria is on Matrix! Check out the official Matrix rooms:

Table of Contents

• Telodendria
  • Table of Contents
  • Download
  • Building The Source
  • Configure Telodendria
  • Project Status
    • Phase 1: Getting Off The Ground
    • Phase 2: Building A Foundation
    • Phase 3: Welcome To Matrix
    • Phase 4: A Real Homeserver
  • Documentation Status
  • Rationale
  • Project Goals
  • Getting Support
  • Contributing
    • Reporting Issues
    • Developing
      • Getting The Code
      • Code Style
      • Subitting Patches
  • License
  • Change Log

Download

Telodendria is distributed as source tarballs, in true Unix fashion. If you want, you can verify the checksum of your download, and check the signature. To check the signature, you'll need signify, and the signify public key: telodendria-signify.pub.

If your operating system has an official package or port of Telodendria, you should prefer to use that instead of manually downloading the source and building it. If your operating system's package or port is too out of date for your tastes, please contact the package's maintainers to notify them, or offer to update the package yourself.

You can check out the change log here.

Building The Source

Telodendria is designed to be light enough that it can be built from source on just about any operating system. It only has the following requirements, all of which should be already available to you on a sufficiently complete operating system:

• A standards-compliant C compiler with a POSIX.1c standard library. Because Telodendria is written in ANSI C and sticks to POSIX.1c features, it should compile on almost any compiler and operating system with minimal effort, but the following compilers are known to work:
  • GCC
  • Clang
  • Tiny C Compiler (Note: must edit make.sh and remove -Wl,-static -Wl,-gc-sections from LDFLAGS)
  Other compilers should work as well, but you may have to play with the flags in make.sh.
• POSIX base utilities, including find, stat, env, and compliant sh-like shell.

If everything went well, that will produce telodendria.cgi, which you can then place under your web root and configure your web server to execute. You'll need to make sure /.well-known/matrix and /_matrix and all the paths under them actually execute telodendria.cgi. See the provided OpenBSD httpd.conf for reference. Even if you aren't using OpenBSD's httpd(8), you should find its configuration syntax simple enough to adequately demonstrate the proper configuration.

Configure Telodendria

Once you get Telodendria built and hooked into your web server, you will have to write a configuration file for it. The configuration file is just JSON, and it should be called Telodendria.json.

Project Status

Telodendria is a very ambitious project. There's a lot that needs to happen yet before it is usable. At the moment, there's nothing that even remotely resembles a Matrix homeserver here; I'm still getting off the ground and building a foundation.

But just because there's nothing here yet doesn't mean you should go away! I could always use help, so you are more than welcome to help out if you want things to go quicker. Please see the Contributing section for details on how you can get involved.

Phase 1: Getting Off The Ground

• Name this project
• Set up a CVS repository
• Make CVS repository public
• Write a coding style guide
• Write a build script
• Add a license
• Add support and issue reporting guide
• Add table of contents to this document

Phase 2: Building A Foundation

• Implement an array
• Implement a logging facility
• Implement argument parsing (-c file -Vh)
• Implement a hash map
• Combine library code files
• Implement configuration file parsing using the hash map
• Base64 encoding/decoding with padded/unpadded support
• Write a release script
• Implement a JSON library using the hash map and array
• Figure out how to wWrite unit tests for array/hashmap/etc
• Add license/documentation comments to all source files
• Implement a simple HTTP server
• Design the server architecture
  • Route requests
  • Handle requests
  • Data abstraction layer
  • Error generation

Phase 3: Welcome To Matrix

• Implement the Client-Server API
• Implement the Server-Server API
• Implement the other Matrix APIs

Phase 4: A Real Homeserver

• Create an OpenBSD package and get it submitted to ports
• Create a command line tool to manage Telodendria
  • Configuration file generation
  • User management
  • Room management
• Migrate from Synapse. I run a Synapse homeserver right now, so somehow I have to get all my data into the Telodendria format.

Documentation Status

This documentation needs just a little work. Here's the things on my list for that:

• Update Rationale section
• Update Project description (no longer a CGI binary)
• Update project code requirements (ANSI C, POSIX.1c)
• Clean up dark mode colors (tables, background, code snippets)
• Add logo (possibly center title?)

Rationale

I want a lightweight Matrix homeserver designed specifically for OpenBSD and other Unix-like operating systems. I want a homeserver that can be developed in vi(1) and compiled with the built-in C compiler. I want it to function entirely on a base OS install without having to install any extra packages whatsoever. I've found that as far as these priorities are concerned, the existing homeserver implementations fall tremendously short. This project aims to point out that existing homeserver implementations are way over-engineered and written in such a way that many programs and libraries have to be pulled in to use them.

I also want to learn how Matrix works, and I want to understand the code I'm running on my server, which is why I'm writing every component from scratch, even the HTTP server.

Telodendria doesn't use a database like all the other homeservers. Instead, it operates more like email: it uses a flat-file data structure similar to Maildir to store data. The advantage of this is that it saves server maintainers from also having to maintain a database. It greatly simplifies the process of getting a Matrix homeserver up and running, and it makes it highly portable. It also is extremely easy to back up and restore with base tools; just tar(1) up the directory, and you're good to go.

Telodendria is developed and tested on OpenBSD, but you'll find that it should just run on any POSIX operating system without modification.

Project Goals

The goals of this project are as follows:

• To be a production-ready Matrix server capable of handling a lot of users. Telodendria should have good performance in many diverse environments.
• To have as few external build and run dependencies as possible. It should be possible to compile Telodendria on any operating system out of the box, and have it be totally statically linked, ready to run under a chroot(8)-ed web server. You'll even notice that the documentation is written in HTML directly, not Markdown, to remove the dependency on a Markdown parser and renderer.
• To be written in clean, elegant, and well-documented code. The goal is to build a Matrix homeserver from the ground up, not just because I don't like the way existing homeservers are implemented, but also so I can learn how Matrix really works, and maybe even teach others along the way.

Getting Support

Telodendria is designed to be fairly straightforward, but that doesn't mean there won't be hiccups along the way. If you are struggling to get Telodendria up and running, you're more than welcome to reach out for support. Just join the #telodendria-general:bancino.net Matrix channel. Before you do though, make sure you're running the latest version of Telodendria and you've thoroughly read through all the relevant documentation.

Contributing

Telodendria is an open source project. As such, it welcomes contributions. There are many ways you can contribute, and any way you can is greatly appreciated.

Reporting Issues

If—after you've reached out to #telodendria-general:bancino.net—it has been determined that there is a problem with Telodendria, it should be reported to #telodendria-issues:bancino.net. There it can be discussed further. The issues channel serves as the official issue tracker of Telodendria; although issues may be copied into a TODO file in the CVS repository just so they don't get lost.

Developing

The primary language used to write Telodendria code is ANSI C. Yes, that's the original C standard from 1989. The reason this standard is chosen, and the reason that it will not be changed, is because the original C is the most portable. Other languages you'll find in the Telodendria repository are shell scripts and HTML. If you have any experience at all with any of these languages, your contributions are valuable. Please follow the guidelines in this section to ensure the contribution workflow goes as smoothly as possible.

Getting The Code

You can download an official release tarball if you would really like, but the preferred way is to check out the source code from CVS. This makes generating patches a lot easier. If you do not have CVS, consult your operating system's package repository to install it. CVS was the chosen version control system for this project primarily because it is built into OpenBSD.

You should now have the latest Telodendria source code. Follow the Code Style as you make your changes.

Code Style

Telodendria's code style is very unique. In general, these are the conventions used by the code base.

• All function, enumeration, structure, and header names are CamelCase. This is preferred to snake_case because it is more compact.
• enums and structs are always typedef-ed to their same name. The typedef occurs in the public API header, and the actual declaration occurs in the private implementation header.
• Indentation is done with spaces. This ensures that files look the same for everyone. It also makes line wrapping rules much easier because the indentations are the same size. Please configure your editor to make the Tab key insert spaces, and if it does automatic indentation, make sure it indents with spaces. If you cannot configure your editor to insert spaces, then you can try running the code files you were working on through expand. A unit of indentation is 4 spaces.
• Lines should not exceed 72 characters, including indentations. Some developers use vi(1) in an 80x24 terminal to write code.

This guide may be subject to change. The source code is the absolute source of truth, so as long as you make your code look like the code surrounding it, you should be fine.

Submitting Patches

Submitting patches is fairly easy to do if you've got the CVS sources checked out. Once you have made your changes, just run cvs diff:

Then, send the resulting patches to #telodendria-patches:bancino.net, where they will be promptly reviewed by the community.

License

All of the code and documentation for Telodendria is licensed under the following terms and conditions:

Change Log

At this time, Telodendria does not have any tagged releases because it is not yet functional as a Matrix homeserver. Please check out the Project Status to see where things are currently at.