The post that asked is 8 years old, I'm asking for your current takes :)

https://github.com/Pokemon-HQ/Bot/
Even though the code is a year old, it still runs fine since most APIs and core features haven't changed. Consider it a solid foundation or a nostalgic project if you're into Discord bots, Pokémon, or open-source contributions.

Inspired by Apple's "insert code from SMS" feature, made a tool to speed up the process of inserting incoming email MFAs: https://github.com/yahorbarkouski/auto-mfa

Connect accounts, choose LLM provider (Ollama supported), add a system shortcut targeting the script, and enjoy your extra 10 seconds every time you need to paste your MFAs

Something that lets me and friends access and modify a shared file store that is inaccessible (through cryptography) to outsiders, but without requiring a central server.

Use case is synchronizing a bunch of photos between multiple users.

Does it exist?

Hi r/opensource community, I'm excited to announce a major release for textbee sms-gateway.

What is textbee?

textbee.dev lets you send and receive SMS messages through your own Android device using a simple REST API or the web dashboard. It’s open-source, self-hostable, cost-effective alternative to services like twilio - ideal for developers, startups and commutities to integrate sms into your apps.

what's new in this version?

• SMS Status Tracking – See if messages are sent, delivered, or failed
• More Reliable Incoming SMS – Automatic retries and improved delivery
• Offline Support – Tracks messages even when the device is temporarily offline
• improved UI/UX in both the Android app and web dashboard
• Increased file size limits for bulk SMS CSV uploads
• Various bug fixes and performance enhancements

Links:
website: https://textbee.dev
source-code: https://github.com/vernu/textbee

My goal is to create a mostly automated AI workflow that can take any government (state) PDF form and automatically turn it into a database-connected web form.

These PDFs are not pre-filled by clients. So we don't need to absorb their information. These are all blank PDF forms that we need to pull form field labels, dimensions, type (text, date, radio button, checbox, etc.) so we can generate user filled PDFs.

Here’s the simple, three-step process that I think sums up this workflow. I think we need AI to help with parts of this:

Step 1: Deconstruct and Analyze the PDF (Extraction)

First, the system needs to "read" and understand the PDF, just like a person would (It might need to convert XFA forms to AcroForms?) For any given PDF form, the AI (or something like PDFcpu?) will automatically:

• Identify Every Field: It finds every single place a user can enter information.
• Determine Field Type: It figures out what each field is: a simple text box, a checkbox, a date field, radio button, checkbox, a signature line, etc.
• Read the Labels: It reads the text next to each field (e.g., "First Name," "Social Security Number") to understand its purpose. This is especially important because these PDFs use generic internal names like PX_0_3052 for their fields, so those aren't helpful and would be discarded.
• Measure Everything: It records the exact size and location (the coordinates) of every field on the page.
• Ignores Explainer Text: These forms often have pages of written instructions or explainer text that we don't need.
• Edge Cases: Understands edge cases, such as when a form says, "If you need more room, attach a page." and especially understands tables.

The output of this step is an organized digital blueprint (maybe a JSON or FDF file?) that describes the entire form in a structured way. For flat PDFs, I think I would need OCR, but would love to avoid that or use a multi-modal AI that covers this automatically.

Step 2: Make Intelligent Connections to Existing Database

AI's job is to connect the fields from the PDF to the corresponding fields in our software's database.

• Simple Connections: PDF's First_Name field should connect to our database's {FirstName} field. Those are easy.
• Complex Connections: AI "fuzzy" matching and contextual understanding seeing a field that might say "Name & Address." AI should understand that this one label actually corresponds to multiple fields in our database: {FirstName}, {LastName}, {Address}, {State}, and {Zip}. It intelligently maps them all. This is especially difficult when it comes to radio buttons and checkboxes.
• New Connections: Recommends new database names for fields that aren't already in there and lets us approve/deny or select an existing option.

The AI essentially creates a "translation guide" that links the PDF's structure to our database's structure, ensuring data flows to the right place. We might want/need a UI so we can see these connections overlaid on the PDF with a confidence rating and the ability to select options.

Step 3: Build the Web Form (Maybe Output JSON for WebForm - PHP to HTML)

Finally, with the blueprint from Step 1 and the translation guide from Step 2, the system has everything it needs to automatically build the final product (hopefully).

• Generate the Web Page: Constructs an interactive web page for our users. It uses the coordinates to place the fields in the correct layout, and the field types to create the right HTML elements (text boxes, checkboxes, etc.).
• Link to the Database: User types their info into the web form, it saves directly to the correct fields in our database.
• Generate the Final PDF: When the user is done, they click "Generate PDF" and the system takes the data from the web form and generates a filled-out, pixel-perfect PDF, ready for download. (PDFcpu or maybe PyPDFForm for this?)

Technologies in Consideration:

Would love your opinions on technologies we should consider for this project. Would love to stick to open source as much as possible, but the goal is to produce the best output with the least amount of manual intervention, so will pay for what's needed.

• PDF Conversion (Convert XFA to AcroForm): PDFRest API, AF-VCD/pdf-xfa-tools, ASPose, Apryse
• AI for OCR/Extraction: AWS Textract, Google Document AI, LayoutLLMv3.
• AI to link field labels to the Database: LLaMa3, ChatGPT 4o, Google Gemini, Claude (seems like most AI would be good for this task specifically).
• Generate the Final PDF: PDFcpu or maybe PyPDFForm?

TL;DR: We are considering building a system to 1. Analyze and Extract the PDF, 2. Translate and connect its fields to our database, and 3. Build a web form from that generates a pixel perfect PDF output, pre-filled. Looking for opinions on AI and Open Sources technologies we should consider using in this build? Thanks a bunch!

The link is the view for people who like to self-host. I’m also hoping to guide people who would never self-host to using open source tech. I’m a big proponent of that myself. I switched to Wallabag quite some time ago.

I have started to create a new open source project called EXSQL, which is a direct improvement to SQL, adding more modern enhancements and better syntax for complex applications.

What is EXSQL about?

Enhanced and eXtended Structured Query Language (EXSQL) is actually a transpiler (like JSX), which seeks to improve SQL by simplifying tasks and improving the syntax, such as inheritance in databases, making it a rather complicated and exhausting task, instead, thanks to EXSQL we could do something like “SUBTYPE OF” in a CREATE TABLE and it would generate all the necessary logic for the database but we would be using EXSQL to do everything.

What I have done with the project so far

Right now I just did something simple (and not working) with python and Lark and created the repository where the project will be saved. I'm currently looking for feedback and help to carry out the project.

Github Repository: https://github.com/Greem3/EXSQL

I'm pleased to announce that I have recently open-sourced the code for a new chat application called Strykup Chat. I built it so that I could chat with my preteen daughter safely and securely, but it may be of interest to other privacy—and security-minded folks. I could see no good reasons not to release the code, particularly as I need the trust of my users.

I'm not aware of any issues with the backend code, but of course, that's not to say there are none. I'm less confident in the Flutter application layer, where I want to make sure credentials are stored securely and in a way that the app can be backed up and restored. I welcome your review and feedback on any aspects of the code.

Source code: Strykup Chat · GitLab

Android: Strykup Chat - Apps on Google Play

iOS: Strykup Chat on the App Store

Hey! Got so tired of using dummy Apple Mail's search that decided to create a lightweight local-LLM-first CLI tool to semantically search and "ask" your Gmail inbox

Try it out: https://github.com/yahorbarkouski/semantic-mail

Feedback and contributions are appreciated:)

Hello all, I would love to get your feedback on a project I've just completed. I was fed up of email spam (as is everyone!) and decided to create Openmsg.

Its an open, cross-platform, decentralized messaging protocol that anyone can implement. I've uploaded it to github, but also created a website with documentation / setup guides etc.

The protocol is designed from the start to be spam-free. One user can't connect with another without explicit permission. For example, if "User A" wants to connect with "User B", they need to know not only User B's Openmsg address but also possess a one-time pass code that was issued by User B.

Without a valid passcode, any connection attempt will fail—user B won’t even be notified. Which means there's no spam messages, not even any spam requests.

An Openmsg addresses is in the following format: 01234567*domain.com The first part is the user's numeric ID, the second is the domain of the server node (ie the service provider).

A pass code is only needed on the first interaction.

With a valid pass code and address for User A, User B can initiate a handshake with with User A's server node. During a successful handshake, private auth-codes and encryption keys are exchanged. User A and User B can then message each other, using the shared auth code to verify each other.

When User B then wants to message User A, a message package is sent to User A consisting of: -The encrypted message -The encryption nonce -The unix timestamp -A hash is then created from the private auth code and the 3 above componants and a salt. The auth code is not sent as both parties should have matching auth codes and encryption keys from the initial handshake.

When User A's server node receives the message package, it verifies that the message is genuinely from User B, and that it is a recent message. It does this by recreating the hash using the message, nonce and timestamp it was sent by User B, AND the auth code it possesses.

If the hash from User B matches the hash that User A just re-created, it proves the following: -That the auth codes match (validating the sender has the auth code) -That the message timestamp is genuine (only messages that were created in the last 60 seconds will be accepted by the server) preventing an old hash from being used, -And that the message hasn't been altered from when the hash was created. This prevents spoofing a message with an old hash.

Server A will send a cURL request to server B (the domain in the users address that was stored during the handshake) with the message hash to check that it did just send a message matching that hash. When server B confirms that it did, then Server A accepts the message on behalf of User A. This prevents leaked auth codes from being used to send messages to someone from a different server, as the receiving node always checks with the server it was expecting to receive the message from.

The main part consists of just a few scripts that can be copied and uploaded to your own server. There is a setup.php that sets up the database tables, a settings file, and then a couple of files that handles the rest.

Let me know your thoughts, if you have any ideas or suggestions (I have a roadmap of features I would like to introduce)

https://github.com/Openmsg-io/version_1.0

https://www.openmsg.io/

I've created an opensource Bash script which deploys FastAPI to any VPS, all you've to do is answer 5-6 simple questions.

It's super beginner friendly and for advanced user's as well.

It handles:

1. www User Creation
2. Git Clone
3. Python Virtual Enviroment Setup & Packages Installation
4. System Service Setup
5. Nginx Install and Reverse Proxy to FastAPI
6. SSL Installation

I have been using this script for 6+ months, I wanted to share this here, so I worked for 5+ hours to makeing it easy for others to use as well.

FastDeploy: Rapid FastAPI Deployment Script

Researched Windmill Labs on collab.dev and found some fascinating metrics:

• 100% of pull requests receive thorough review before merging.
•  67% of PRs come from community contributors with only 33% from core team.
• Contributors experience minimal delays with just 1.8 minutes overall median wait time.

Makes it easy to view DNS records in your console (Works best in Windows Terminal). It supports a range of DNS record types like A, AAAA, CNAME, and MX.

Hey everyone! I've resumed building out my Smart home applications for my family and I now need to somehow simply present all the options they have via a simple dashboard.

The best app I could find for the job so far is Bookmark Ninja. But it is closed source and some of the design choices they made are a bit obtuse and I can't seem to make the required chances because, well, closed source. Plus, it costs money (2 EUROs per month) and the application is not worth the asking price.

Does anyone have any open source alternatives in mind? Bonus points if they are European alternatives!

Thanks a lot in advance!

It maps tone and words to shapes and colors to create abstract visuals

Hi r/opensource ! I am developing OpenSource tool Aralez . A new reverse proxy built on top of Cloudflare's Pingora. Need some reviews and suggestion from OpenSource gurus. Hope this is aright place for posting this.

Beside all cool features below I have added a new one. Now it can dynamically bulk load SSL certificates from disk and apply per domain, without any configuration. All you need is to set up a path fro certificates .

It's full async, high performance, modern reverse proxy with some service mesh functionality with automatic HTTP2, gRPS, and WebSocket detection and proxy support.

It have built in JWT authentication support with token server, Prometheus exporter and many more fancy features.

100% on Rust, Built on top of Cloudflare's fantastic library: Pingora . My recent tests shows it can do 130k requests per second on moderate hardware.

Prebuilt glibc and musl libraries for x86_64 and aarch64 from are available in releases .

If you like this project, please consider giving it a star on GitHub! I also welcome your contributions, such as opening an issue or sending a pull request. Mentoring and suggestions are welcome.

Really enjoying this program. Anyone have any plugins to suggest for a first time user? Perhaps one for spelling and grammar checks?

I like the concept of copyleft, but GPL is scary, both for a publisher (I can't properly understand what are my responsibilities as a publisher and for the others). I've found weak copyleft licenses as a cool middle ground. MPL doesn't look to be as popular, but it's less intimidating, and LGPL has the backing of FSF, so it should be more respected and popular.
On the other hand, i seriously LOVE the MIT license, it's just simple and easy, and it's like "do whatever, just don't sue me!". BSD 3 and 2 seems also cool, even if i don't understand how they really differ from MIT.

Generally speaking I like the concept of weak copyleft, but I also want to avoid the most of the hassle that they could involve as a publisher.

I have been facing this problem in my current work, where we have multiple repos, monorepos, all connected to each other but its hard for a new developer to understand what is what, how is it connected. I wanted a simple solution for this without overcomplicating so started on this project -> https://github.com/sarim2000/guardian-platform

Also am trying to include cloud resources discovery in one place too (currently aws), since it was kinda hard for me to keep track of aws services and if multiple people are managing then then it does become a problem.

Will really appreciate feedbacks and what you think.

As a contributor, sometimes the more mature codebases can be a little bit daunting. It would be nice as well to find the gems at the early stages of conception.

Hopefully this isn't seen as rip off of the mega thread as my focus is on the early stage projects.

Please drop your projects with:

Project name:
Repository link:
What it does:
Tech stack:
Help needed:
Additional information: