Waytale

News

Newest news first. You can subscribe by RSS too. If you want to get notified on big, infrequent updates (every few weeks or months), you can enter some way to contact in this form.

Please note that any news can get dated and Waytale is continuously being worked on. The development logs here often report on bleeding-edge changes. As such, actual releases of Waytale may include more refined work than what the screenshots and descriptions represent at time of writing.

2026-05-29: Secure identities

The last two weeks have concluded a lot of technical, low-level work related to user identities and related security features. This post is a bit longer and split into two parts: Technical considerations and when they become more visible to the person using Waytale. There were some other things happening too, but this entry will be dedicated to security-related topics.

Security measures in Waytale

A lot of thought was spent on how to design security-critical code properly, a lot of documentation was read, and different strategies were attempted to establish certain security guarantees (or at least not horribly wrong). Where are we at?

What’s an ID, really? Safe design in peer-to-peer networks is difficult, especially when there is a stack of technologies involved. How do you establish a persistent identity in a network of fleeting peers? Which parts depend on which? Below is a glimpse of some of the moving parts involved. All of those are different forms of identification and need to be orchestrated meaningfully and securely. They are sorted from technical low- to high-level within Waytale, or (put differently) more to less ephemeral information:

Yjs is the library providing smart data structures that are magically synchronised over the network (CRDTs). Yjs builds on Simple-Peer as the basis for WebRTC-based peer-to-peer communication. Waytale builds on those data structures for robust network communication between peers on maps and gadgets. And now identities are built on top of that.

Making them dance. Merely grouping those forms of identification (bullet points above) with each other solves only half the problem. When it comes to a person’s digital identity (in Waytale), you want things to be safe against accidental and intentional manipulation. So you want all that information checked for internal validity and integrity among those units, as well as have it timestamped, digitally signed, protected from impersonation, and resistant against e.g. denial-of-service attacks. Waytale implements some defences now to make sure peer connections are secure and your chosen identity stays safe.

Here’s one to the gadgets. On top of that, every time you interact with a gadget that can connect you with somebody else, a separate data channel is established to keep information to those who it is addressed to. This secondary channel per gadget per peer must be linked to a peer with verified identity information (as described above) and some additional security checks must be satisfied, e.g. is the avatar close enough to the gadget to interact with it? Some other forms of access control on a personal level are planned.

Everyone take notes. Not every network can transmit information in high speed, correct order, or even 100% reliably, and we all benefit from being a little forgiving in such cases. However, violations of security protocols are a different beast. Not even assuming bad intent, a peer who does not play by the rules can rain on the party for everyone else. In centralised service architectures (i.e. not peer-to-peer), a server would typically be performing security measures and access control. In Waytale, every peer enforces all security checks for every other peer, and any suspicious activity will be reported to the human using Waytale and answered with the destruction of the connection with the peer in question.

I could be wrong. While I try to stick to modern standards and protocols, proper web development with security-critical technologies is not easy. I acknowledge that I am not a security expert and may make mistakes. To fill those gaps, the agenda holds some items for the future: Some more security mechanisms catering to Waytale’s specifics, automatic code analysis, and an independent security audit. Security is not a milestone, but a continuous effort. Last but not least, Waytale is open source and feedback to make it better is always appreciated.

Verifying identities

Now that those big changes under the hood are becoming stable and coming to a close (for now), I may turn to more visible features again for a while. One of them is getting more detailed information about the other people in the space. Click/tap on an avatar to view what they share about themselves.

View somebody else’s profile by clicking/tapping on an avatar.

Eventually, this tab will show a little bit more information about the other person (if they decide to disclose that information), but there was a specific motivation in the given security context of this post: You should always be able to manually inspect your own and another person’s identity.

The fundamental question is: How do you ever know the person on the other end is who they claim to be? This is a common problem in many, also non-technical situations. For example, imagine receiving a text message in some instant messenger from somebody who claims to be somebody you actually know, but who you never texted with before. How do you know they are not an impostor (or relatedly that your communication channel is secure)?

Your specific situation may allow for different ways to approach the problem. (Are you talking in real time? Are you both authenticated by some trustworthy authority?) But most commonly it is a good thing to be able to manually verify the identity of the other peer over a separate communication channel in some way. To conclude the example before, modern instant messengers often offer to display an account-specific code (e.g. Signal’s “safety numbers”) to verify the other end’s authenticity.

This is now possible in Waytale too: By clicking/tapping on an avatar, the person’s identity is displayed in hexadecimal code and graphically. You can use this information to verify another person’s digital identity: If they click/tap on their own avatar and send you what they see, and you click/tap on their profile, and what you receive is the same, then you can be certain you are talking to the correct person and your communication channel is secure.

That’s it for this time. While there were a few other things cooking, reporting will follow some other time.

2026-05-08: Lab week and then some

What two weeks those were! Most notably, during this period of the closed beta, some more people tried out Waytale and I received a lot of great feedback of what’s good, what could be improved on, and where the journey could go. Thanks to all people contributing! ♥️

The beta-test space. An adapted version is scheduled for public release when Waytale transitions from “closed beta” to “open beta”.

Next to those things, last week was the Lab Week, which meant a lot of thorough researching, fun experimentation, and iterative trial and error. There are a few handy tools planned and last week got the process started on some of those, which is useful when it is need to sometimes tinker and sometimes let problems marinate for a while and return later. Things that were worked on last week:

Generating Waytale maps based on some input data requires smart, constraints algorithms. The diagrams show intermediary outputs of experiments with very constrained algorithms. Imma just drop that here mysteriously without much explanation (for now!).

This week was busy with work closer to the engine of Waytale. Most importantly, work on “user identites” was started, which enable you to be recognisable to (the devices of) other people in the same space. This is not trivial, since Waytale builds heavily on peer-to-peer technology and compared to server-based services there is no central authority that verify that you are who you say you are. So some smarts had to go into that process and it has been cooking for a while.

Of course you can always choose to stay anonymous (“throw-away identities”) via private/incognito mode of your browser. However, stable user identities will allow for some convenience functions (think friend lists) and moderation tools. In any case they also provide the basis for security measures to make sure that all people in the same Waytale space behave cooperatively. This is great for publicly accessible spaces where not everyone knows everybody.

Specifically, the most fundamental code for creating, signing, and verifying identities happened this week. There is a lot more to be done but the groundwork is done, which includes a lot of figuring things out on paper to be future-proof and compatible with some other planned features.

In other news, there was the need to use some software library function, which was not available due to an outdated dependency of a dependency. Drilling down to the root problem revealed some surprising configuration choices of dependencies (import of already optimised bundles and some other things). Accounting for that (bundling unoptimised code ourselves) led to a leaner dependency tree and 200kb smaller file size. Nice!

2026-04-29: New release of the Waytale Viewer!

Finally, the Waytale Viewer has gotten a new release! All existing pre-made spaces were updated to include the new Viewer release. What’s new you ask? Why, let me speak to you through imagery.

A new tab called “🔨” (working title) allows placing new gadgets on the map.

The most glorious feature is being able to add new gadgets to the map yourself. That includes editing and removing existing ones, of course. Work is not finished here and the user interface will change a little in the future, but it’s usuable already. 🎉

After selecting a gadget type, gadget-specific options can be entered. You can place the gadget on the map by dragging the big preview icon and dropping it on the map where you see fits. (Huge, majestic hand for visualisation purposes and not included in Waytale.)

Adding gadgets yourself already allows new ways to interact with Waytale spaces. While the current selection of gadget types is limited, it includes Jitsi-based video calling, embedding of external websites, writing notes (Markdown-based), a collaborative whiteboard, and a shared Etherpad.

(More gadgets are already in the works. As soon as some internal, technical interfaces are stable, it will be easy to create gadgets yourself.)

Once placed on the map, the gadget behaves as usual: Walk close to it and to interact with it.

Being able to add gadgets yourself to any existing space can already be useful on its own. It’s also possible to share gagdets with others now (see recent news entries), which for example allows writing texts or embedding websites and make this accessible for other people.

By clicking/tapping on the gadget, you can view details or (if you’re the owner) edit and remove.

Other improvements of the new release include better mobile support (especially navigation and zooming) and a little nicer form and user interface elements. There was some other preparatory work going on in the last days, but more on that next week.

2026-04-17: Shared gadgets finishing up

Continuing the work of the last time on shared gadgets, some time was devoted to testing and bug hunting (to have gadgets appear when they should and only once), as well as preparing the important aspect of shared gadgets allowing to share data easily. The next released gadget types will include some basic chat functionality, which will benefit directly from shared data access.

In that context some preparations were made for access control and identity verification. (I like my chat messages delivered only to the people I’m talking to.) That involved reading a lot of technical documentation (hello WebRTC) and also source code of other projects, but more on that in a few weeks.

Speaking of gadgets, the Markdown gadget was made more usable and all gadgets got some small tweaks here and there. Together with two new tilesets (see tileset repository), these changes benefit an upcoming demonstration or tutorial-style space. This space will get a closed-beta treatment in the next weeks and eventually released publicly as well.

2026-04-12: Happy holidays!

I hope you had nice holidays! As mentioned briefly in early February, development was on pause in the last four weeks due to other personal commitments.

Last week working on Waytale was picked up gently again. Most visible changes are improvements in the user interface, especially better support for browsers on mobile devices in navigation, pinch-zoom, and creating shared gadgets, but also various other small tweaks here and there. Also: Exporting maps was made more flexible, got better error handling, and was documented online.

Not so much visible at the moment is finishing the shared gadgets feature (testing edge cases). Preparations are made for gadgets that provide more interactive features by building on shared data structures (Yjs’ CRDTs). As some security measures are involved (access control), some groundwork needs to be laid for identity management already. More on the matter will follow in the next weeks!

Most of the officially released spaces feature gadgets that allow video calling based on Jitsi. This is not ideal, as a pre-configured Jitsi instance for all spaces means putting some load on an external service. The instance was changed now and might change again in the future until an alternative solution is put into place (likely a video-related gadget without external dependency).

That’s all for now. Regular updates will continue now again on a weekly basis!

2026-02-27: Shared gadgets

This week’s work was dedicated to a new feature that is central to the idea of Waytale: Shared gadgets.

Interactive functionality in the maps of a space are provided by one or many embedded gadgets. So far gadgets could only be defined by the map (i.e. the map’s creator). Now it’s possible for anyone to add a new gadget to any map visiting.

The way this works is by selecting a gadget from a list of space-wide installed gadget types, maybe setting some gadget-specific options, and finally drag-n-dropping it somewhere onto the map.

The creator (owner) of a gadget can remove their created gadgets again and edit gadget-specific options (more on that next week). Anyone can click/tap on a gadget to see more details.

(Work in progress) An avatar looking at an Etherpad gadget. It was clicked/tapped to show an information page with more details. (Btw, gadgets now glow when selected and hooray for colourful tab icons.)

If a gadget is shared, everybody else in the map will also see it, otherwise only the gadget creator can see it. You’re in a meeting and the map creator did not include a whiteboard? Just create one. You’re in classroom and fancy a game of solitaire? Well…

But wait, 🤔 allowing anyone to add gadgets anywhere could easily get chaotic, right? Some peer-based moderation features are planned, but some other core functionality needs to happen first (e.g. identity management). More information follows soon.

Technically speaking, 🤓 many parts of the program code had to be touched (vertical integration), redesigned, or upgraded from scaffolding code to proper implementation. This was planned and expected. Most prominently this includes the now more utilised Yjs library, which provides rock-solid CRDT-based underpinning for data synchronising data between peers.

Work on shared gadgets will continue next week for some more UI polish and better gadget-specific settings. Shared gadgets are an important feature for Waytale, as it defines the project’s profile further and helps setting it apart from similar software that provides spatially-structured social spaces.

2026-02-20: New Space: Café

The big news of the week is: A new Café space! The intended purpose for it is to use as an open space you could host yourself and distribute a link publicly.

Curious to try? This website hosts all official spaces to try. If you want to take a sneak-peak of the upcoming space releases, head over to the list of demo spaces and have a look around. Instructions for how to install a space yourself follow soon.

Please note: Not everybody likes to enter a video call with strangers at unexpected moments. Fear not! While currently video calling is heavily utilised, features to moderate a comfortable level of bumping into each other are in the works.

Having a cozy virtual sip of coffee at the cozy virtual café.

What else is new this week? The tooling to generate maps and how Gadgets are technically defined got overhauled. This was one necessary step on the way to stabilising the Gadget API, so more work on Gadgets can happen soon.

Other than that various other things got tweaked and tuned. The documentation was restructured and a small issue in the RSS feed (thank you Jochen!) got fixed. Much people-facing text in the toolbox got polish and a couple of smaller bug-fixes and code improvements.

2026-02-13: Tooling and code quality

The last week’s work focussed on 3+1 areas.

Gadgets. The code of and around gadgets was proofed a lot and some gadgets got lifted from proof of concept to release-ready. This includes video calling (using the great Jitsi software), embedding of arbitrary markdown documents (which you could store alongside your Waytale space), and embedding of arbitrary websites for general convenience. When the interface between gadgets and the Waytale Viewer has settled, corresponding documentation (“Gadget API”) is going to be released.

Toolbox. A lot of work happened on the tooling that helps with setting up and managing Waytale spaces and maps. More specifically, the waytale program got extended with a lot of functionality. Click and open one of the boxes below for a short preview of the new commands. Tutorials for effective use of those tools are coming soon, but the eager reader can already hop over to the Toolbox repository and experiment a little.

Space design. A small selection for ready-to-deploy spaces is planned and work on the next spaces has started. Next will be 1. café-like space that is intended for public use and configured accordingly (e.g. no video-calling or opt-in) and 2. in the project’s self-interest a space that showcases features and possible uses of Waytale. Work on those spaces will continue next week.

Code quality. Other than those three more substantial main areas, some work happened to improve code quality (stricter linting etc.), some refactoring of early code, and proper code documentation.

waytale --help 
Usage: waytale [OPTIONS] COMMAND [ARGS]...

  Various tools to manage Waytale spaces and maps.

Options:
  --help  Show this message and exit.

Commands:
  check     Perform health checks for a space and its maps.
  download  Download one of the official Waytale spaces.
  export    Export one or more Tiled maps into a Waytale map.
  init      Create a new Waytale space.
  serve     Run a local web/signalling server for a Waytale space.
  update    Update the configuration of a space.
waytale init --help 
Usage: waytale init [OPTIONS] DIRECTORY

  Create a new Waytale space.

  This command currently supports downloading a pre-configured space from the
  list of officially released Waytale spaces and asking some questions for
  personalisation. It is roughly equivalent to running the following commands:

      waytale download DIRECTORY
      waytale update DIRECTORY
      waytale check DIRECTORY

  The "quiet" and "force" parameters are passed along, if provided.

Options:
  -f, --force  Continue if target directory already exists. May overwrite files.
  -q, --quiet  Be less verbose about what's happening.
  --help       Show this message and exit.
waytale download --help 
Usage: waytale download [OPTIONS] DIRECTORY

  Download one of the official Waytale spaces.

  This command fetches an up-to-date list of officially released Waytale
  spaces. One of those is selected (see below), then the corresponding archive
  downloaded and extracted into the target directory.

  A space to download is selected either interactively, by picking a space
  from a displayed list of released possible spaces. Or it is selected
  automatically by picking the latest release of a space with a name matching
  the --latest argument. The specified search term need not be a the full
  space name (partial matching), but it must refer to exactly one space
  unambiguously.

Options:
  -l, --latest SEARCH-TERM   Be less verbose about what's happening.
  --strip-dir-levels NUMBER  When extracting archives, skip this many top-
                             level directories.  [default: 1]
  -f, --force                Continue if the target directory is not empty.
                             May overwrite files.
  -q, --quiet                Be less verbose about what's happening.
  --help                     Show this message and exit.

2026-02-06: Closed beta-testing

The development process has entered the next phase: Closed beta testing! This phase is planned to last few weeks, where the current (humble) set of features can be tested by a small circle of people. After this, a public call for beta testers will be published.

The last week was filled with big and small fixes and improvements across all repositories. First versions of gadgets for collaborative writing (using Etherpad) and drawing/whiteboard (using WBO) were made. Those will be polished in the next weeks and some more gadgets are planned for next week. Having multiple gadgets open at the same time is possible now. The landing page was updated a little for clearer communication what Waytale is about and some screenshots.

Due to other commitments in March, the schedule for the public beta version is not yet fixed. But it will be announced here in the next weeks, stay tuned!

2026-01-30: First Waytale space almost release-ready

The living room of the home space and onboarding instructions in the second pane.

The last days were very busy with work towards the first release. This will include the first official Waytale space, which will be a homely house. The design for this “home” space is near complete and is going through practical testing and bug-fixing of the pre-configured gadgets.

The kitchen of the home space and the settings pane.

The space builds on a number of tilesets, which were gathered from different sources. In the process some Tiled-compatible tilesets were created that can freely be used for Waytale projects and outside of it (see respective readme files and license information).

The office of the home space and a drawing gadget embedded in that office.

The Viewer received a lot of improvements and bug fixes. More prominent changes include: Better spatial navigation, display of the zoomed space, settings styling, and error communication. Development tools (waytale command and release scripts) were streamlined.

More information to follow next week!

2026-01-26: Preparing the first release

The first few days of the year were devoted to a different planned commitment (worked out fine). Back to Waytale!

Current work focuses on getting a first release of a Waytale space ready, so people interested can try it out and play around with it already. If you have access to some web space, the process ideally is as simple as downloading a ZIP file, extract it, modify a file a little (e.g. name your space), and uploading all files (more details on installing here).

That first release requires a bit of functionality and assets in a basic version. This includes the following parts (more actually, but let’s keep it short).

A note on the last point: While the internet is full of tilesets, not every set of graphics is suitable for technical, stylistic, or legal (licensing) reasons. A curated list of suitable tilesets will be kept in the Tilesets repository and a tool is in the works to help with license-related tasks such as crediting.

In other news: Want to stay up to date on Waytale developments without checking manually all the time? You can now subscribe by RSS feed.

2026-01-03: Happy new year!

Happy new year from Waytale! Looking forward to a year with many exciting developments planned!

Not so much has happened over the holidays, mostly due to recovering from sickness and closing the year. Some other planned commitments will be keeping me busy until the middle of next week, but then I will be happy to continue working on Waytale, including a couple of new features. Until then!

2025-12-21: Weekly roundup

Last full week before Christmas! The focus was on the last polish before making a first alpha version available (scheduled for next week). Today’s post also summarises some small here-and-there efforts scattered over the last weeks.

Most notably, all repositories (listed under the Waytale organisation on Codeberg) are now updated with the last local changes! From now on updates should be pushed more frequently. Here is a short repository overview:

In case it is not obvious, please note that this is all very work in progress and the current state does not constitute the final set of features. There might be rough edges here and there and missing features, but more is to come in the next months.

The website you are reading this on is currently split into 2+1 main parts:

Other than that, in preparation for the planned alpha release, a robust release mechanism was set up to manage the releases and assets as outlined above efficiently. Supporting that, the Viewer got a very Friday-afternoon update-reminder in case newer version are available.

If time allows there will be another update in the next days. Either way, merry Christmas to all readers who celebrate!

2025-12-15: Weekly roundup (double feature)

The news item from last week got lost in the hustle and bustle of parallel job commitments, overlapping deadlines, bouts of sickness, and, well, it being December. Not so many flashy things happened in each week, so here is a double feature.

The last two weeks included a lot of smoothing out rough edges in many different places. More visibly, this covered a better onboarding experience in new spaces and some user interface improvements. Since pictures are nice, so here is a sneak preview of the current state (text continues after). Please note: Very work in progress of course and may be familiar with people who know the prototype. Either way, expect changes in the future.

The (upcoming) demo space on the left and the context-dependent elements on the right, currently showing some greeting documents.

Regarding internal changes, some parts of the Viewer code got made more robust and prepared for planned features. Preparations for irregular releases of asset repositories were made. Repositories were (locally) updated to match some standards to e.g. have proper readme and license files.

During restructuring into multiple repositories and it took a little time for the dust to settle. So much stuff is approaching a proper state locally and I’m looking forward to publishing them and then keep working in the public under the Waytale organisation on Codeberg.

Finally, updates are coming to the website (which you are reading). Documentation will be coming before Christmas, a demo space for quick trying out, and some time in the future also API documentation for the Viewer.

2025-12-01: Weekly roundup

Today completed the work of last week, which was about finishing the last last steps to reach feature parity with the public prototype. Hooray!

To a large degree this included setting up the gadget framework, including boilerplate functionality like activating a gadget when close, loading of external dependencies, and so on. Also work started on two reference gadgets (displaying markdown documents and Jitsi integration) with many others to come.

Another big block of time went into re-creating some important UI features, notably the tab view, welcome/help pages and the settings pane. While dependencies of Waytale are being kept as small and robust as possible, the settings now build on an external library which will provide a lot of flexibility for per-gadget settings as well.

2025-11-21: Weekly roundup

In a personally short week, the last days were largely invested into a couple of smaller boring under-the-hood changes. The Waytale project is divided into a couple of repositories somewhat reflecting the Outline. This streamlines build processes (e.g. of the “viewer” part, documentation, or this website) and releases of assets (e.g. tilesets). Most of those repositories are not online yet, but probably get put online this or next week. Stay tuned!

Other than that, the groundwork for gadgets was rewritten (from Tiled maps to interactive in the “viewer”), some tools for testing were created, and the planned structure structure was redone to be a bit cleaner.

2025-11-14: Weekly roundup

Last week was mostly continuing the rewrite of the Waytale navigator. Space and map loading works, walking around, and now also the WebRTC core, so now you can see the avatars of other people walking about. Rewriting already paid off here.

In other news, preparations were made for online API documentation. Some more background information was put into this website. Anyone building with Waytale (including me right now) will require a local development setup and a new helper tool will simplify this part a bit.

2025-11-07: Weekly roundup

In the last and this week focus was mostly on rewriting the core features of the main interface of Waytale. The demo so far was a lot of copy-pasted code to see whether it works, but not maintainable. For the new code base a model-view-presenter pattern will be employed and it’s looking much tidier so far.

Other than that, some tilesets were prepared for public use and a new demo space is being worked on, which will eventually be linked on the landing page of the project.

2025-10-27: Website online

Well, hello world.

2025-10-16: Funding by NGI Zero

The Next Generation Internet Zero coalition spearheaded by NLnet selects the Waytale project for the NGI0 Commons Fund call from April 2025. The NGI0 Commons Fund provides grants to people who help build the digital commons.

2024-11-19: Prototype

First “proof of concept” is uploaded and experimented with over the following months.