• 2 votes
    See my PR for polls implementation https://github.com/fluxerapp/fluxer/pull/1129
  • 1 vote
    Right now, Fluxer has optimistic messages (the message appears in the channel grayed out until the server confirms that it has actually been sent). So what happens is, the optimistic message is sent, then when the server confirms the success, the message is recreated entirely and replaces the optimistic variant. This makes the task much harder than "a line of script". Trust me, I tried with custom CSS lol. So Fluxer would need to change the way messages appear in the channel for animations to work. Maybe we could try to make sure that, instead of deleting the optimistic variant and recreating the confirmed message, the message's root element's content would be edited so that the root element itself could be animated properly? I'm sure someone could try this out.
  • 1 vote
    the client sends the message key to the instance admin.
    From my understanding, that runs the risk of exposing other messages in the channel, due to next keys being generated based on the previous ones. Though it's been a while since I looked at this stuff, so I don't exactly remember how good the post-compromise security is, so I'll have to check. That being said, message signing itself might be a complicated piece of math, but choosing what we cryptographically sign isn't. Choosing which metadata gets signed along the message is just a matter of changing the content that gets signed, nothing more. Additionally, message signing is already a crucial part of Polyproto, which is going to be used for Fluxer's federation.
  • 1 vote
    Looking at people's ideas in discussions is just not the current focus rn
  • 2 votes
    Hi, I'm a dev who writes code by hand and contributes to Fluxer. See https://github.com/fluxerapp/fluxer/pull/1129 ? It had 20k added lines of code in about 2 weeks of intermittent work, and that's me not working full time with some significant amount of time spent reading the codebase I wasn't familiar with. That diff is almost twice as big as my immediate-mode Rust GUI framework that I wrote over the course of more than a year. Turns out, Fluxer's codebase architecture just leads to big diffs, is all. I think that instead of just looking at the number of lines of code added, you should take into consideration the amount of these lines that come from generated files. Notably, all of the locales, which use a file format that points back to places in the source code and therefore are susceptible to any source code changes, and the massive OpenAPI JSON files, to cite the biggest culprits. I'd also note that GitHub seems to use a weird diff algorithm. When Hampus started committing to the repo again a few months ago, there was one huge commit that showed 10 million lines of code added, yet when cloning the repo and looking at that commit locally, it was only 3 million, and 2/3rds of that were from automatically generated files. (I analyzed that whole commit back then.) I'm not saying Hampus isn't currently using LLMs to generate anything (in fact first time translations are generated with AI and that's disclosed in the application), only that you can't just look at the number of lines of code on GitHub and judge based on that.
  • 1 vote
    Ah, shucks! Didn't think about that one implication... welp
  • 1 vote
    If I understand correctly, is TEST SYSTEM supposed to be the name of the main account? It should probably not look like it's a different kind of bot. I think that to indicate that this is someone talking through a persona, using a stack of two circles for the profile picture would potentially be better, with the main account's pfp largely hidden by the persona's pfp. image I'm thinking of these two cases. The left one is what's displayed when multiple people are typing, the second one is made up but seems more readable to me after trying it. It has slightly smaller circles with a bigger spacing to better see part of the circle in the background. Maybe with that kind of display you wouldn't need to directly show the system name? Either way a stack like this would be good I think
  • 1 vote
    Language neutrality is one thing, but importing from PluralKit is just a useful functionality. What's wrong with having it?
  • 1 vote
    Looks pretty good from the screenshot! Just a few things about design:
    • I'd ensure that the Import from PluralKit and Add Subprofile buttons look like the rest of the buttons on the platform; right now the icon is above the text instead of on its left. The rounding is also off. Looking at your PluralKit modal commit, it looks like you used plain HTML <button>s, it would be better to use Fluxer's own Button (fluxer_app/src/features/ui/button/Button.tsx) component instead. Same for the other buttons if you did it that way there too.
    • I'd slightly increase the width of the subprofile switching modal in the second screen so that Last Used doesn't span two lines of text.
    Also, I think the vocabulary is a bit inconsistent. In one place we're talking abut "subprofiles", in another it's "personas", and in another it's "subprofiles & personas". I think it should just be "subprofiles", it's the most neutral word that corresponds to the broadest application of this feature imo.
  • 1 vote
    I know it has been suggested that when a new device is added, it can obtain the required encryption material from an existing trusted device. However, what happens if a user loses all of their devices or clears all local data? Is the expectation simply that they lose access to their messages, or do server instances retain enough information to allow recovery of the decryption keys? If server instances do retain recovery information, that information would obviously need to be encrypted before being uploaded. However, at that point it feels as though the federation is collectively storing all of the information required to recover access to the user's messages, just in a more complicated form. How is that fundamentally different from storing an encrypted zip file of the user's messages in cloud storage?
    Not sure if I was clear about that, but the section on where messages should be stored mentions encrypted cloud message backups. That is, the user gets to choose whether to backup their messages to their instance or not. If they choose to not backup their messages, then they have more security, but they risk losing access to all their DMs if they lose all of their devices. You can indeed think of these cloud backups as essentially encrypted zip files, yes. It would be encrypted with the user's password, or with a key stored encrypted in the user's profile that can be retrieved on login after the device has been verified. As a reminder, the goal of E2EE is to encrypt communications in transit and this it doesn't dictate anything about storage, hence why we decided to be flexible on where messages are stored in our discussions and why I specified cloud message backups as a default opt-out in this design plan to maximize positive UX.
  • 1 vote
    For anyone who wants the fix for this, you need to add this env variable in docker-compose.yaml:
    FLUXER_PASSKEY_RP_NAME: ${FLUXER_PASSKEY_RP_NAME:-Fluxer}
    FLUXER_PASSKEY_RP_ID: ${FLUXER_PASSKEY_RP_ID:-fluxer.app}
    
    Note
    (the Fluxer and fluxer.app values are just default values, you can set them to anything you want.)
    Then, in .env, you can set FLUXER_PASSKEY_RP_NAME to whatever name you want and FLUXER_PASSKEY_RP_ID to your instance domain.
  • 1 vote
    @valtteri1010 You mean Fluxer's own Caddy deployment?
  • 1 vote
    I've been informed that there is a whitepaper on encrypted collaboration spaces. Looking at their performance numbers, it would suggest that E2EE for large communities might actually be possible in the future! 👀 Edited the post with this information
  • 1 vote
    The problem might actually suggest a contrast- or light-level-based spoiler mechanism, which also wouldn't be a bad idea
  • 1 vote
    That is an extremely broad question, but I guess I could partially answer it. I think E2EE channels, especially DM channels, largely won't affect the development speed of future feature implementations too much, as long as those features don't include the server being able to know the content of messages. Say for example Fluxer's markdown implementation adds new features, then E2EE isn't gonna slow anything down because it only applies once the messages have been decrypted. It would definitely increase development complexity though, since the limitations of E2EE channels (unscalability of the algorithm after a few hundreds of members) have to be taken into account when developing features. For example, if you had secret channels in communities, how would permissions be affected? What if you give to a role the permission to see that channel, but that role has more members than what the secret channel can accept? In this specific case you have to inform the user that that's not possible because the role has too many members. Now what if you do the same thing with a role that has just enough members to receive that permission, but then you add a member to that role? That's also not possible. So it means that to implement secret channels in communities, you'd have to, at minimum, add a piece of code in the "add role" and "update permissions" functionalities of the application to have additional non-happy paths. But, it's also important to highlight the fact that E2EE is not the focus of Fluxer in the first place. Most features pertain not to privacy of small groups, but to public communities: stuff like slash commands, forums, creator monetization etc. are pretty much completely separate concerns, and they likely won't have anything to do with E2EE channels inherently. (Though I may be wrong on that.) As for an estimation, well... I've never been able to estimate something I've never developed before, so someone else might be able to answer that... But I can't x')
  • 1 vote
    I'm not sure about "more lightweight", but it's definitely more modern than OpenGL (which has stopped receiving updates 8 years ago) and gives you a lot more fine-grained control. Problem is, I'd need to learn it, and that's gonna take a while... So I'm doing Metal first :p
    And no, I don't want to use WGPU. It's way too much abstraction, and from my point of view it's yet another API to learn. I'd rather learn Metal and have something solid on all platforms, then add Vulkan after that. I can have a lot more freedom with my renderer by making this myself, and it's fine because I already have something that works.
    Reply on the edit: Thank you :3 Edit: another possibility would be to use Core Animation, which was a friend's suggestion. Though it would require me to make a second renderer rather than add a backend to my existing renderer. I guess I'll look into it.
  • 1 vote
    I intend to make my own native desktop client for Fluxer using my own GUI framework with my own simple OpenGL renderer, all written in Rust. It's immediate-mode, cross-platform, has hot-reloading (thanks tosubsecond), supports stuff like unicode text (thanks to parley), text input and animations, and has a widget inspector. I still need to add some important things like a Metal renderer for MacOS (the OpenGL renderer is too slow on MacOS right now), some kind of way to make custom shaders (won't take too long) and accessibility (using accesskit), but apart from that it's pretty much usable. Here's a demo of what I have so far. https://fs.speykious.dev/showcases/uing/uing-demo-6e72fb7.mp4 Here's a smaller video demonstrating hot reloading since GitHub doesn't want to embed the previous video. 557966331-f897c6f9-6e17-40d5-9bc8-f37e503cd469.mp4
  • 1 vote
    Forgive me for I have forgotten that it was literally mentioned in the roadmap 💀 https://blog.fluxer.app/roadmap-2026/#7-emoji-and-sticker-packs

    # 7: Emoji and sticker packs

    A lot of Discord users can probably relate to joining loads of communities just to use their emojis and stickers globally. Fluxer would instead let you save emoji and sticker packs created by others directly to your account, if you prefer.
  • 1 vote
    See https://blog.fluxer.app/how-i-built-fluxer-a-discord-like-chat-app/#frequently-asked-questions

    What about the open web?

    This is something I'd like Fluxer to do something about. Fluxer will eventually have a discovery system of public forum channels, Atom/RSS feeds, and server-side rendered, public, unauthenticated views of forum channels that can be found on search engines and archived, as an entirely opt-in thing to get the best of both worlds.
  • 1 vote
    They could be called "subprofiles" even. And apart from accessibility it could also double as a QOL feature for roleplaying.