With the rise of widespread government monitoring programs, Tox is an easy to use application that allows you to connect with friends and loved ones without anyone else listening in.
Tox isn't ready yet, downloads will be available soon!
About Tox
Tox is built with the idea that you can keep up with friends and family without having your privacy violated. While other big-name services require you to pay to unlock features, Tox is free in both price, and in liberty. That is, you’re free to do whatever you wish with Tox。
--------------------------------
用tox加密skype的聊天内容
The web forum 4chan is known mostly as a place to share juvenile and, to put it mildly, politically incorrect images. But it’s also the birthplace of one of the latest attempts to subvert the NSA’s mass surveillance program.
When whistleblower Edward Snowden revealed that full extent of the NSA’s activities last year, members of the site’s tech forum started talking about the need for a more secure alternative to Skype. Soon, they’d opened a chat room to discuss the project and created an account on the code hosting and collaboration site GitHub and began uploading code.
Eventually, they settled on the name Tox, and you can already download prototypes of the surprisingly easy-to-use tool. The tool is part of a widespread effort to create secure online communication tools that are controlled not only by any one company, but by the world at large—a continued reaction to the Snowden revelations. This includes everything from instant messaging tools to email services.
It’s too early to count on Tox to protect you from eavesdroppers and spies. Like so many other new tools, it’s still in the early stages of development and has yet to receive the scrutiny that other security tools, such as the instant messaging encryption plugin Off The Record has. But it endeavors to carve a unique niche within the secure communications ecosystem.
‘Up to Your Imagination’
The main thing the Tox team is trying to do, besides provide encryption, is create a tool that requires no central servers whatsoever—not even ones that you would host yourself. It relies on the same technology that BitTorrent uses to provide direct connections between users, so there’s no central hub to snoop on or take down.There are other developers trying to build a secure, peer-to-peer messaging systems, including Briar and Invisible.im, a project co-created by HD Moore, the creator of the popular security testing framework Metasploit. And there are other secure-centric voice calling apps, including those from Whisper Systems and Silent Circle, which encrypt calls made through the traditional telco infrastructure. But Tox is trying to roll both peer-to-peer and voice calling into one.
Actually, it’s going a bit further than that. Tox is actually just a protocol for encrypted peer-to-peer data transmission. “Tox is just a tunnel to another node that’s encrypted and secure,” says David Lohle, a spokesperson for the project. “What you want to send over that pipe is up to your imagination.” For example, one developer is building an e-mail replacement with the protocol, and Lohle says someone else is building an open source alternative to BitTorrent Sync.
The New Skype
That said, the core Tox team is focused on building the features specifically required for building a Skype replacement. There are at least 10 different Tox messaging and voice clients so far, each supporting a different range of features. Eventually, Lohle says, there will be “official” clients for each major operating system, but for now the team is just recommending a few specific clients. µTox, which is available for Linux and Windows, is a the “bleeding edge” reference design, while qTox is the project’s recommendation for OS X users and Antox is the recommended for Android. There is no recommended iOS version as of yet, but there there is at least one client available.µTox is still rough, but the interface and experience is straightforward. You download the client, and it automatically creates a public encryption key that you can provide to everyone, and a private encryption key that you keep on your computer or phone. From there, it works very much like Skype. You can add a friend to your contact list by pasting in their public key, and then you just click their name to send them a message, or click the big phone icon to call them. If you want to move your identity from one computer to another, you just copy a single file that includes your private key and contact list.
There are still a few features that are missing, though. For example, although you can do a group text chat, there’s no way to do a group voice chat yet. And there’s no way to be logged in as the same person on two different devices — say, both your phone and your computer. But Lohle says those features are coming, and the team already has a proof-of-concept for how group voice chat will work.
He says the team has no plans to turn it into a company or monetize it in any way. “No one getting paid, but we dedicate as much time as we can,” he says. “If I’m not in class, or I’m not eating, I’m probably working on Tox, and that’s at least the same for probably 10 people.” Besides, the lead developer, known only as irungentoo, is completely anonymous, so it would be hard to issue him a paycheck. “I don’t think any of us know his real name,” Lohle says.
The Link With 4Chan
Today Lohle downplays Tox’s relationship to 4chan. “We were self-sufficient after only a couple weeks,” he says. “We also posted on reddit and hacker news, and people joined from that.” He probably has good reason to distance the project from the site. The racism, homophobia and misogyny on display on the 4chan on a day to day basis would be a big turn off both for users and potential contributors.The association has also exposed the project to the trolling and drama characteristic of the forum, which often makes it hard for outsiders to evaluate. For example, one Tox developer raised concerns about Tox users exposing their IP addresses to each other. The team responded by masking IP addresses through a technology called onion routing — the same technique that the Tor Project uses to protect user anonymity on the web. But the fix didn’t stop a wave of paranoia from sweeping forums, and it’s hard to tell how much of that is trolling and how much of it is legitimate concern.
Can You Trust It?
Worse, the project let its “warrant canary” page go offline for a week. A warrant canary is usually a website that states that a company or organization has not be served by a secret subpoena from the NSA or any other law enforcement or intelligence agency. It’s meant as a way to bypass laws that prevent companies from warning their customers that they have been served with a national security letter. The Tox team claimed in a blog post that they simply forgot to put the warrant canary back online after moving web hosts. But the incident led to degree of understandable suspicion.Meanwhile, few security experts outside the project have reviewed the Tox code yet, but the project is based on an existing set of code libraries for working with crypto algorithms called NaCl, which has received considerably more attention. “NaCl is a newish library that is nevertheless very highly regarded in the security community, produced by skilled people,” says the Electronic Frontier Foundation senior staff technologist Jacob Hoffman-Andrews, who hasn’t yet evaluated Tox.
But it’s entirely possible to implement good crypto libraries in poor ways, so the Tox team is saving money to hire a professional security firm to audit the code once it reaches a more stable state. “Right now we’re relying on the open source community,” Lohle says. “We have about 15 who stare at the code for days or weeks.”
Correction 6:30 PM EST 9/1/2014: An earlier version of the story referred to the Electronic Frontier Foundation as the Electronic Freedom Frontier. It has also been updated to clarify that group text chat is possible with in Tox, but not group voice chat.
Correction 1:00 PM EST 9/2/2014: This article has been updated to clarify that although there is no recommended iOS client for Tox, there is at least one iOS client available.
from http://www.wired.com/2014/09/tox/
----------------------------------------------------
开源安全P2P版聊天软件 Tox，可能替代Skype
连线杂志报道，来自网络匿名论坛 4chan 的几位程序高手近日开发出了一个开源的，经过加密的，P2P 去中心化管理版本的 Skype 聊天工具——Tox。开发者声称未来将会将 Tox 打造成为一个能够有效防御任何来自政府或其他非法人士窃听行为的加密通讯工具。
其实 Tox 目前并非一个终端级别的软件，而是一种加密过的 P2P 数据传输协议。如上所说，Tox 除了足够安全（尽管现在不能算最高水准的安全等级，但也已经比部分其他主流即时通讯软件加密水平高）之外，最大的特性就是不需要一个集中管理的服务器——去中心化。在一个去中心化的网络拓扑结构当中，两个或多个进行数据交换、信息沟通的节点以 P2P 的方式进行连接，而非需要将数据上传到云，然后云重新将数据分配给对象。关于去中心化的网络拓扑结构，你可以阅读《网状网络：世界末日的希望》一文了解。
Tox 的开发团队致力于将这个功能打造为「Skype 的替代者」。Tox 目前已经拥有多达 10 种客户端，每种都具有不同的功能。Tox 团队表示将会在未来推出一个适用于目前主流桌面和移动操作系统平台的「官方版」软件。
如果有读者希望尝试这种新的沟通方式，Windows 用户可以选择μTox，OS X 用户则应当选择 qTox，而 Android 用户的首选应该是 Antox，以上三个都是 Tox 开发团队推荐的软件版本。
--------------
再说一遍Tox是啥?
新建一个Tox个人资料
修改个人资料
添加好友
E1F1C7DEA73D8126A1DEE9EAE5B45E21FB17E75F2319B7823A346B8C427EB272C80A89B69B4E—Tox ID 是像这样的十六进制数呗~
发起群聊
最后
7BC803F7F9B8A7230EE181AB45CA909DE446D36A7BC3A275D5576439E0CF7546FF4E2C4665CC
Tox —— 安全的P2P聊天工具，完美取代Skype
| Windows | Linux | OS X | FreeBSD |
|---|---|---|---|
| 64 bit release | Arch, Gentoo | Latest release | Package & Port |
| 32 bit release | Building instructions | ||
| 64 bit, 32 bit nigthly | Other |
注意：注册账号不要使用中文哦。最好是 英文 或 英文+数字。
首先，打开 Toxme 的主页 https://toxme.io/
这是一个超级简单的网页。英语恐惧症者也不要慌，我介绍一下我们会用得着的几个地方。
红色椭圆 sign up：注册。也就是把 76 位 ID 注册为邮箱格式的账号。
下划线 edit your record：编辑你的记录。也就是修改已经注册的账号信息。
红色方框 Find some friends here：在此找找朋友。也就是查看那些已经注册了邮箱格式的网友。想要添加老外网友的，可以来这里找哦。
Name：你想要的账号名，如 pig，注册成功后，Tox 账号就是 pig@toxme.io 啦。
Tox ID：你的 76 位 ID，从 qTox 里复制粘贴到这里。
Bio：写一段话，用于发表在这个网站上。随便写，也可以不填。
红色方框 Hide my name from the public list：如果勾选，表示注册后，你的账号不会发布在这个网站上（就是前面讲的罗列已注册账号的那个页面）。建议不要勾选！
填写好后，点击底部大大的"Publish"按钮，即可注册成功。
人数不少，有很多页，找老外朋友的不妨用点耐心。
如果你是 Linux qTox 用户，还可以直接在本机的 qTox 软件上注册（Windows 版 qTox 不行哦）。如图所示，点击顶部自己的账号名称，右侧显示个人信息页面。【注：我把这个地方用中文详细解释一下。直接在客户端软件上注册邮箱式的用户账号，操作方式与网页版差不多。先点击pTox软件上自己的用户名或图像，然后在打开的窗口里往下拉，看到注册 ToxMe, 里面已经默认填上了你的用户名，如果想用别的名注册邮箱，直接在此处更改即可，然后点注册就行了】
qTox：支持全部的 ID 格式，包括 76 位 ID、utox.org 格式、toxme.io 格式。
uTox：只支持 76 位 ID 和 utox.org 格式。
正鉴于此，还魂草建议大家统一去 https://toxme.io 注册 ID，不要再去 utox.org 注册了。
A New Kind of Instant Messaging
https://github.com/irungentoo/toxcore
Redesign of Tox’s Cryptographic Handshake
In 2017, Jason A. Donenfeld (known for WireGuard®) reported an issue in Tox’s handshake [1]. This issue is called “Key Compromise Impersonation” (KCI). I will try to explain the issue as simple as possible:
In Tox you don’t register an account (e.g. with username and password), but instead your identity is solely based on (asymmetric) cryptographic information, a so-called asymmetric key pair. Such a key pair consists of a public part (public key) and a private part (private key). The public part, as the naming suggests, is public and contained in your ToxID which you share with your contacts to be able to communicate with them via Tox. The private part, again as the name suggests, needs to stay private! If someone gets in possession of your private key, they stole your Tox identity. This could, for example, be the case if someone got physical access to your computer or successfully installed malware on your system, e.g. a so-called trojan horse, to be able to extract data from it. If this happens, you will most likely have multiple problems and your Tox identity may be just one of them. The password you enter when you create your Tox profile, e.g. when you first start qTox client, is used to encrypt your profile and also your private key on your disk. If you start qTox, you need to enter your password to decrypt your private key, to be able to communicate via Tox. Your private key is then stored unencrypted in memory (i.e. RAM) while qTox is running. This means an attacker either needs to get access to your password (steal or crack it) or to read your Tox private key from memory while your Tox chat client is running.
If someone successfully stole your Tox identity (i.e. this private key), they are you – at least in the context of Tox. So they can successfully impersonate you in Tox. Now in this case the KCI vulnerability leads to “interesting” behavior. It is clear that someone who stole your identity is able to impersonate you. But because of the KCI vulnerability, they may also be able to impersonate others to you. This means, to exploit this vulnerability in practice, someone not only needs to successfully steal your private key, but additionally:
- Know the ToxIDs of your Tox friends to be able to impersonate them to you.
- Control the network connection between you and your friend. This could be the case e.g. if they are in the same (public) WiFi as you, or via the Internet – which is way harder and is most likely only possible for state actors (e.g. the NSA).
- Implement their own version of toxcore because it’s not possible to exploit this issue with the current implementation. There is no public exploit available which can just be used.
In summary, KCI is exploitable, but with a huge effort.
Anyway, this is a real vulnerability and it should be fixed. The current Tox handshake implementation is not state-of-the-art in cryptography and it also breaks the “do not roll your own crypto” principle. As a solution, there is a framework called Noise Protocol Framework (Noise, [2]) which can be used to create a new handshake for Tox. More precisely, the application of Noise will only change a part of Tox handshake — the so-called Authenticated Key Exchange (AKE). Noise-based protocols are already in use in e.g. WhatsApp, which uses it for encrypted client-to-server communication, and WireGuard®, which uses it for establishing Virtual Private Network (VPN) connections. Noise protocols can be used to implement End-to-End Encryption (E2EE) with (perfect) forward secrecy (which is also the case with the current Tox implementation), but further adds KCI-resilience to Tox.
Tobi (goldroom on GitHub) wrote his master’s thesis (“Adopting the Noise Key Exchange in Tox“) on the KCI issue in Tox, designed a new Handshake for Tox based on NoiseIK and implemented a proof-of-concept (PoC) for this new NoiseIK-based handshake by using Noise-C [3]. This PoC has a few drawbacks, which is why it should not be used in practice (see Appendix). If you want to know more about his master’s thesis, see the update in the initial KCI GitHub issue [4].
He applied for funding at NLnet foundation and their NGI Assure fund to continue his work on Tox and to be able to implement a production-ready Noise-based handshake for toxcore. Fortunately, this application was successful [5]. NGI Assure is made possible with financial support from the European Commission’s Next Generation Internet programme (https://ngi.eu/).
The objective of this project is to implement a new KCI-resistant handshake based on NoiseIK in c-toxcore, which is backwards compatible to the current KCI-vulnerable handshake to enable interoperability and smooth transition. The main part of this project is to implement NoiseIK directly in c-toxcore to remove Noise-C as a dependency (as the only other dependency for c-toxcore is NaCl/libsodium) which was used in the PoC and therefore improve maintainability of c-toxcore (see Appendix).
The tasks in this project are:
- Implementation of a Noise-based AKE for the use in Tox’s handshake in c-toxcore
- This task is to implement and test an AKE for the Tox handshake based on a Noise protocol (most likely
Noise_IK_25519_ChaChaPoly_SHA512, but it may change due to new insights in c-toxcore).
- This task is to implement and test an AKE for the Tox handshake based on a Noise protocol (most likely
- Implementation of a symmetric transport phase encryption based on a Noise-based AKE/handshake
- This task includes the implementation of a symmetric transport phase encryption based on the secret key(s) generated during the Noise-based AKE during the Tox handshake and evaluation of Noise’s rekey feature.
- Subtasks:
- Decision of which symmetric cipher to use for the Tox transport phase encryption (e.g. ChaCha20-Poly1305 or XSalsa20-Poly1305)
- Evaluation of Noise’s rekey feature to allow for session rekeying to reduce the volume of data encrypted under a single cipher key (cf. section 11.3 of Noise specification, revision 34). This may not be applicable to be implemented in c-toxcore (e.g. changing keys may be expensive). Also, it may not be necessary for ChaCha20 / XSalsa20. Further, it’s dependent on how the transport phase encryption will be implemented.
- Support for the Noise-based AKE and the KCI-vulnerable AKE for backwards compatibility
- This task includes the implementation of a mechanism to fall back to the KCI-vulnerable handshake if one of both peers uses a legacy c-toxcore version to provide backwards compatibility for the handshake transition phase (e.g. via cookie phase (request and response) of Tox’s handshake).
- Error handling and testing, Documentation, Blog posts
The plan is to implement this new handshake until July 2023. Since it’s not a trivial task, there are still some obstacles:
- In Noise it is necessary to differentiate between the initiator and responder of a handshake. Due to the architecture of Tox it is possible that both peers initiate and respond to a handshake at the same time.
- Tox is P2P and UDP-based. Therefore packets can be received
out-of-order or be lost altogether. In the Noise specification this is
only considered for transport messages (cf. [6]).
-
“Note that lossy and out-of-order message delivery introduces many other concerns (including out-of-order handshake messages and denial of service risks) which are outside the scope of this document.” (cf. [6])
-
Both points are not ideal for a handshake based on NoiseIK (i.e. it would be way easier to implement it in a client-server model using TCP), but it should be possible to work this out.
Tobi is available in #toktok (libera.chat) as tobi/@tobi_fh:matrix.org and ready for any input, questions, remarks, discussions or complaints.
Appendix:The PoC shouldn’t be used in practice/in production because it should be improved in the following aspects (for details see chapter five of Tobi’s thesis [4]):
- The PoC was implemented by using the Noise-C library [3]. Instead of using the library, NoiseIK or more specifically the
Noise_IK_25519_ChaChaPoly_SHA512protocol will be implemented directly in c-toxcore. This will remove Noise-C as a dependency for toxcore (i.e. the only other dependency is NaCl/libsodium) and therefore improve maintainability. Additionally this will reduce the number of possibly vulnerable source lines of code.- Notes on maintainability: Noise-C has a lot of code/functionality which is not necessary for c-toxcore. Also Noise-C is currently (?) not actively maintained. If NoiseIK is implemented directly in c-toxcore it is only necessary to maintain the c-toxcore codebase and it is not necessary to care about Noise-C.
- The PoC implementation uses the ChaCha20-Poly1305 AEAD cipher during the AKE/handshake and XSalsa20-Poly1305 during the transport phase. In this project it should be evaluated if it’s possible to also use ChaCha20 during the transport phase to only use one cipher instead of two different ones (XSalsa20 is not supported by the Noise framework). For details see chapter four of Tobi’s thesis.
- Further testing of NoiseIK handshake behavior and improved error handling.
- The PoC implementation is not backwards compatible with the current KCI-vulnerable Tox handshake. In this project a mechanism should be added to enable interoperability with clients based on an old c-toxcore version.
- [1] Tox Handshake Vulnerable to KCI #426: https://github.com/TokTok/c-toxcore/issues/426
- [2] Noise Protocol Framework: https://noiseprotocol.org/
- [3] Noise-C Library: https://github.com/rweather/noise-c
- [4] More information on Tobi/goldroom’s master’s thesis: https://github.com/TokTok/c-toxcore/issues/426#issuecomment-759511593
- [5] “Adopting the Noise Key Exchange in Tox” project description/information: https://nlnet.nl/project/Noise-Tox/
- [6] Noise specification, 11.4. Out-of-order transport messages: https://noiseprotocol.org/noise.html#out-of-order-transport-messages
from https://blog.tox.chat/2023/03/redesign-of-toxs-cryptographic-handshake/
With the rise of government surveillance programs, Tox, a FOSS initiative, aims to be an easy to use, all-in-one communication platform that ensures full privacy and secure message delivery.
Website | Wiki | Blog | FAQ | Binaries/Downloads | Clients | Compiling
IRC Channels: #tox@freenode, #tox-dev@freenode
The Complex Stuff:
UDP vs. TCP
Tox must use UDP simply because hole punching with TCP is not as reliable. However, Tox does use TCP relays as a fallback if it encounters a firewall that prevents UDP hole punching.
Connecting & Communicating
Every peer is represented as a byte string (the public key [Tox ID] of the peer). By using torrent-style DHT, peers can find the IP of other peers by using their Tox ID. Once the IP is obtained, peers can initiate a secure connection with each other. Once the connection is made, peers can exchange messages, send files, start video chats, etc. using encrypted communications.
Current build status:
Q&A:
What are your goals with Tox?
We want Tox to be as simple as possible while remaining as secure as possible.
Why are you doing this? There are already a bunch of free Skype alternatives.
The goal of this project is to create a configuration-free P2P Skype replacement. “Configuration-free” means that the user will simply have to open the program and will be capable of adding people and communicating with them without having to set up an account. There are many so-called Skype replacements, but all of them are either hard to configure for the normal user or suffer from being way too centralized.
TODO:
Documentation:
qTox is a chat, voice, video, and file transfer IM client using the encrypted peer-to-peer Tox protocol.
https://qtox.github.io/
qTox is a chat, voice, video, and file transfer instant messaging client using the encrypted peer-to-peer Tox protocol.
User Manual | Install/Build | Roadmap | Report bugs | Jenkins builds | Mailing list | IRC: #qtox@libera.chat
| Windows | Linux | OS X | FreeBSD |
|---|---|---|---|
| 64 bit release | Arch, Debian, Fedora, Gentoo, openSUSE, Ubuntu | Latest release | Package & Port |
| 32 bit release | AppImage, Flatpak | Building instructions | |
| 64 bit, 32 bit nightly | From Source, Flatpak nightly, AppImage nightly | Latest nightly |
Bold options are recommended.
Builds other than installer/packages don't receive updates automatically, so make sure you get back to this site and regularly download the latest version of qTox.
Help us
If you're wondering how could you help, fear not, there are plenty of ways
Some of them are:
- Spread the good word about qTox to make it more popular
😄 - Have an opinion? Make sure to voice it in the issues that need it
😉 - Fixing easy issues or issues that need help. Make sure to read Contributing first though
😉 - Testing and reporting bugs
- Translating, it's easy
- Reviewing and testing pull requests – you don't need to be able to code to do that
😉 - Take a task from our Roadmap below
Roadmap
Currently qTox is under a feature freeze to clean up our codebase and tools. During this time we want to prepare qTox for upcoming new features of toxcore.
The next steps are:
- move all toxcore abstractions into their own subproject
- write basic tests for this Core
- format the code base
- rethink our Issue tracker
The current state is tracked in the Code cleanup project.
Screenshots
Note: The screenshots may not always be up to date, but they should give a good idea of the general look and features.
Features
- One to one chat with friends
- Group chats
- File transfers, with previewing of images
- Audio calls, including group calls
- Video calls
- ToxMe and Tox URI support
- Translations in over 30 languages
- Avatars
- Faux offline messages
- History
- Screenshots
- Emoticons
- Auto-updates on Windows and packages on Linux
- And many more options!
Organizational stuff
Happens in both IRC channel #qtox@libera.chat and on qTox-dev mailing list. If you are interested in participating, join the channel and subscribe to the mailing list.
There are IRC logs available.
from https://github.com/qTox/qTox
( qTox-端对端加密聊天软件，去中心化，让你的即时通信获得保密性和安全性。
tox最早于2013年6月23日由irungentoo发布并托管于GitHub上，此后的几年tox迅速发展，并衍生出许多基于tox制作的客户端，包括今天我们主要介绍的-qTox。
tox最初的想法就是创建一个像微信，QQ一样的即时通讯工具，但它无需使用中央服务器运行，并且点对点，端到端加密，保证用户通信的保密性和安全性。
qTox就是一款基于Qt和tox制作的端对端加密即时通讯工具，随着政府监控项目的兴起，qTox提供了一个易于使用的软件让您能够在与亲人和朋友联系的时候防止他人的偷窥，qTox 完全免费，并且没有广告。
qTox 特点:
跨平台：支持windows、linux和mac
方便：支持文本、音频、视频通话
安全：点对点端对端加密，没有中心服务器
简单：qTox使用简单，不需要任何专业知识，你只要专注于聊天
自由：qTox是完全免费的。除了免费使用，还能自由修改它
qTox使用:
首先qTox是点对点通信，没有中心服务器，这就意味着使用qTox无需注册账号。下载客户端后直接运行，自动生成账号（76 位的十六进制字符），其实就是我们常见的一机一码。
qTox添加好友也很简单，复制对方的76位ID发送请求即可，添加成功后就可以愉快的进行聊天了。
qTox支持语音和视频聊天，通话质量不错，而且qTox还支持圈子（其实就是分组），而且支持群聊。
文件传输这么基础的功能当然也是支持的。
github地址：https://qtox.github.io/
中文官方:https://qtox.github.io/zh_CN.html)
-----
Tocks
A Tox client with no good reason to exist. Please check out qtox for a fully featured and maintained project.
Goals
- First and foremost the author's enjoyment
- Well enough abstracted that UI toolkits can be swapped out in the future
- Stable/well tested/easily testable
- Not necessarily feature packed. Whatever people want to implement can be implemented
Technical details
The project is split into several crates
- toxcore-sys: Bindings to c-toxcore
- toxcore: Rust API for tox functionality
- tocks: Application logic/state
- ui: QML UI around tocks library
Currently toxcore/tocks are tied to tokio. At a high level, tocks runs a future on the tokio runtime that waits for an "event" to happen. This could be anything that triggers us to take an action (e.g. the user sends a mesage, or a friend request is received from toxcore). Once we get an event we handle it and wait for the next one.
At the moment the design is that each subset of functionality will wait for something to happen, and when it does bubble an event up to the top of the tocks app. The tocks main loop will then dispatch the event back down to whatever component needs to handle it. This approach allows us to parallelize all reading of state, but still enforce one mutable writer in the handler portion. Hopefully performance of this pattern will not be so bad that events back up, otherwise we will have to split functionality further so we can handle several types of events at once.
Status
- Proof of concept QML UI implemented that can login + send/receive messages to friends
