Looking for open source app so download music

Uhh I remember I had an app to download music but I literally forgot it's name guys help me out

https://redd.it/1pdygw0
@r_opensource

A file-based Postman alternative

Hi all, I have been working on an open-source Postman alternative for a month and I have just finished the first set of key features:

# File-based API client

* Define workspaces, collections, and requests in JSON
* Works well with Git, code review, and keeping API examples next to your code

# Mock servers

* Define local HTTP/HTTPS endpoints in JSON
* Jest-style matchers in configs, like `any(String)`, `stringContaining('foo')`, etc.
* Request **forward** (acts like a proxy)

# Middlewares

For example `requestMiddleware` that gives you full control before/after a request. Useful for auth, logging, custom workflows, etc.

Next, I plan to add API testing automation features etc. It does not have much difference to other similar projects now, but it could be interesting soon.

Intro and docs are here: [https://hanlogy.github.io/api-studio/](https://hanlogy.github.io/api-studio/)

What do you think? :)

https://redd.it/1pe0jyl
@r_opensource

Java SpringBoot library for Kafka - handles retries, DLQ, pluggable redis cache for multiple instances, tracing with OpenTelemetry and more

I built a library that removes most of the boilerplate when working with Kafka in Spring Boot. You add one annotation to your listener and it handles retries, dead letter queues, circuit breakers, rate limiting, and distributed tracing for you.

What it does:

Automatic retries with multiple backoff strategies (exponential, linear, fibonacci, custom). You pick how many attempts and the delay between them

Dead letter queue routing - failed messages go to DLQ with full metadata (attempt count, timestamps, exception details). You can also route different exceptions to different DLQ topics

OpenTelemetry tracing - set one flag and the library creates all the spans for retries, dlq routing, circuit breaker events, etc. You handle exporting, the library does the instrumentation

Circuit breaker - if your listener keeps failing, it opens the circuit and sends messages straight to DLQ until things recover. Uses resilience4j

Message deduplication - prevents duplicate processing when Kafka redelivers

Distributed caching - add Redis and it shares state across multiple instances. Falls back to Caffeine if Redis goes down

DLQ REST API - query your dead letter queue and replay messages back to the original topic with one API call

Metrics - two endpoints, one for summary stats and one for detailed event info

Example usage:

u/CustomKafkaListene(

topic = "orders",

dlqtopic = "orders-dlq",

maxattempts = 3,

delay = 1000,

delaymethod = delaymethod.expo,

opentelemetry = true

)

u/KafkaListener(topics = "orders", groupid = "order-processor")

public void process(consumerrecord<string, object> record, acknowledgment ack) {

// your logic here

ack.acknowledge();

}

Thats basically it. The library handles the retry logic, dlq routing, tracing spans, and everything else.

Im a 3rd year student and posted an earlier version of this a while back. Its come a long way since then. Still in active development and semi production ready, but its working well in my testing.

Looking for feedback, suggestions, or anyone who wants to try it out.

https://redd.it/1pe1w41
@r_opensource

Set Up Your Mac Development Environment in Minutes with Hola

Ever spent hours setting up a new Mac for development? Installing Homebrew packages, configuring dotfiles, tweaking system settings, arranging your Dock... it's tedious and error-prone. What if you could automate everything with a simple Ruby DSL that reads like plain English?

Meet Hola – a blazing-fast development environment manager that combines the best of Homebrew, mise, and dotfiles management into one cohesive tool.

## The Problem with Existing Solutions

I've been a long-time Chef user because typing endless brew install or apt install commands drives me crazy. Chef's Ruby DSL is perfect – it's readable and expressive. But Chef comes with heavy dependencies, especially on macOS where it installs unnecessary components and even creates system users.

Other configuration management tools? Ansible and Salt force you to write complex YAML files when you'd rather just type commands directly. Popular dotfiles managers have steep learning curves for what should be a simple task: symlinking files to the right places.

## Enter Hola: Convention Over Configuration

Inspired by modern tools like Ghostty and Bun, I built Hola in Zig for its speed, cross-compilation capabilities, and seamless C integration. The result? A tool that sets up your entire development environment in minutes, not hours.

### What Makes Hola Different?

1. Convention Over Configuration – Use tools you already know:

Brewfile (Homebrew's native format):

brew "git"
brew "neovim"
cask "ghostty"
cask "visual-studio-code"

mise.toml (mise's native format):

[tools]
node = "24"
python = "3.14"
rust = "stable"

2. Optional Ruby DSL – For advanced provisioning (90% of users won't need this):

# ~/.config/hola/provision.rb
package ["git", "tmux", "neovim"]

execute "install-oh-my-zsh" do
  command 'sh -c "$(curl -fsSL https://ohmyz.sh/install.sh)"'
  not_if { Dir.exist?(File.expand_path("~/.oh-my-zsh")) }
end

3. Intelligent Dotfiles Management – No complex configs needed:

# Bootstrap from a GitHub repo (clones + installs packages + links dotfiles)
hola apply --github username/dotfiles

# Or just link dotfiles from local directory
hola link --dotfiles ~/.dotfiles

4. macOS Desktop Configuration – The killer feature that even Chef doesn't offer:

# ~/.config/hola/provision.rb
macos_dock do
  apps [
    '/Applications/Ghostty.app/',
    '/Applications/Visual Studio Code.app/',
    '/Applications/Safari.app/',
  ]
  orientation "bottom"
  autohide true
  magnification true
  tilesize 50
  largesize 40
end

macos_defaults "show hidden files" do
  domain "com.apple.finder"
  key "AppleShowAllFiles"
  value true
end

macos_defaults "keyboard repeat rate" do
  global true
  key "KeyRepeat"
  value 1
end

## Getting Started in 3 Minutes

### 1. Install Hola

# Quick install (recommended)
curl -fsSL https://hola.ac/install | bash

# Or using Homebrew
brew tap ratazzi/hola
brew install hola

# Or download manually
curl -fsSL https://github.com/ratazzi/hola/releases/latest/download/hola-macos-aarch64 -o hola
chmod +x hola
xattr -d com.apple.quarantine hola
sudo mv hola /usr/local/bin/

### 2. Create Your Dotfiles Repo

Create a GitHub repo with these files:

Brewfile (in repo root):

brew "git"
brew "gh"
brew "ripgrep"
brew "fzf"
cask "ghostty"
cask "zed"
cask "raycast"

mise.toml (in repo root):

[tools]
node = "20"
python = "3.12"
go = "latest"

~/.config/hola/provision.rb (optional, see "macOS Desktop Configuration" section above for examples)

### 3. Run It

# One command to set up everything!
hola apply --github username/dotfiles

That's it! Hola will:
- ✅ Clone your dotfiles repo to ~/.dotfiles
- ✅ Install all Homebrew packages from Brewfile
- ✅ Install and pin tool versions from mise.toml
- ✅ Symlink dotfiles to your home directory
- ✅ Run

provision.rb (if exists) for Dock/system settings

## Real-World Use Cases

### Migrate Your Current Setup

Export your existing configuration:

# Export current Dock configuration
hola dock

# Export Homebrew packages to Brewfile
brew bundle dump

### Team Onboarding

Create a company dotfiles repo with Brewfile:

# Core tools every developer needs
brew "git"
brew "docker"
brew "kubectl"

# Company-specific tools
cask "slack"
cask "zoom"
cask "visual-studio-code"

And ~/.config/hola/provision.rb for advanced setup:

# Install VS Code extensions
execute "install vscode extensions" do
  command "code --install-extension ms-python.python"
  command "code --install-extension dbaeumer.vscode-eslint"
  not_if "code --list-extensions | grep -q ms-python.python"
end

# Clone team repositories
directory "/Users/#{ENV['USER']}/work" do
  recursive true
end

git "/Users/#{ENV['USER']}/work/backend" do
  repository "git@github.com:company/backend.git"
end

Then new hires just run:

hola apply --github company/dotfiles

### Personal Dotfiles Management

Bootstrap your entire environment with one command:

# Clone repo, install packages, link dotfiles - all in one
hola apply --github username/dotfiles

# Hola automatically:
# 1. Clones https://github.com/username/dotfiles to ~/.dotfiles
# 2. Installs packages from Brewfile
# 3. Installs tools from mise.toml
# 4. Symlinks dotfiles/ directory to ~/
#    ~/.dotfiles/dotfiles/.zshrc → ~/.zshrc
#    ~/.dotfiles/dotfiles/.gitconfig → ~/.gitconfig
#    ~/.dotfiles/dotfiles/.config/ghostty → ~/.config/ghostty

## Performance That Matters

Built in Zig, Hola is incredibly fast:

- Dock configuration: ~50ms (vs seconds with AppleScript)
- Dotfiles linking: <100ms for hundreds of files
- Package installation: Limited only by Homebrew/mise speed
- Memory usage: <10MB resident

## Why Developers Love It

"It's like Chef, but without the baggage" – Hola gives you Chef's beautiful Ruby DSL without the heavyweight dependencies.

"Finally, Dock management that works" – No more manual dragging or complex AppleScript. Define your Dock layout in code.

"Convention over configuration done right" – Smart defaults mean less typing. Hola knows where dotfiles should go.

## Advanced Features

### Conditional Logic

Use Ruby's full power in provision.rb:

# In ~/.config/hola/provision.rb
if ENV['USER'] == 'john'
  package "discord"
end

case node['platform']
when 'darwin'
  package "mas"  # Mac App Store CLI
when 'ubuntu'
  apt_repository "ppa:graphics-drivers/ppa"
end

### File Templates

template "/Users/#{ENV['USER']}/.gitconfig" do
  content <<~GITCONFIG
    [user]
      name = #{ENV['GIT_NAME'] || 'Your Name'}
      email = #{ENV['GIT_EMAIL'] || 'you@example.com'}
    [core]
      editor = nvim
  GITCONFIG
end

### Resource Notifications

Chain resources together:

file "/etc/app/config.yml" do
  content "production: true"
  notify :execute, "restart-app", :immediately
end

execute "restart-app" do
  command "systemctl restart app"
  action :nothing  # Only runs when notified
end

## Try It Today

Stop wasting time on manual setup. Whether you're setting up a new Mac, onboarding team members, or just want reproducible configurations, Hola makes it simple.

# Install
curl -fsSL https://hola.ac/install | bash

# Bootstrap from your dotfiles repo
./hola apply --github username/dotfiles

Or start simple with just a Brewfile:

# Create a Brewfile
echo 'brew "git"' > Brewfile
echo 'cask "ghostty"' >> Brewfile

# Run apply in current directory
hola apply

GitHub: https://github.com/ratazzi/hola

Installation: https://github.com/ratazzi/hola#installation

---

Built with ❤️ in Zig by developers who value their time.

What's your Mac setup routine? Have you tried Hola? Share your thoughts in the

comments!

https://redd.it/1pe2m58
@r_opensource

Looking to Connect With GSoC Org Admins for Guidance (We’re Expanding Our Open Source Efforts)

Hey everyone, Akshay here. I’m working as DevRel at my company, OLake. We’ve been growing our open source efforts internally we even ran our own Hacktoberfest campaign, announced bounties around $100, and saw some really great contributions from the community.

Now, we want to take things a step further and explore becoming part of GSoC. Since this is our first time, I’m hoping to connect with people who have managed GSoC before either as organization admins or mentors. I’d really like to understand how you handled the process, what things you had to take care of, and what you think new orgs should prepare for.

If anyone here has experience with getting an organization into GSoC or running it in previous years, your guidance would be super helpful. Even a short explanation or a quick chat would mean a lot. We’d love to make sure we do things the right way and build something meaningful for contributors.

Thanks in advance, and if any org admins are open to sharing their experience, I’d love to connect and work together on this.

https://redd.it/1pe13t4
@r_opensource

Building a small open-source CI/CD engine. I would love technical feedback & a github star
https://github.com/open-ug/conveyor

https://redd.it/1pe9w3e
@r_opensource

Loopi: Open-Source Visual Browser Automation Tool (MIT Licensed, v1.0.0 Released)

Hi r/opensource community,

I've been working on a tool that might fit into the automation space for browser tasks, and I'd love to hear your thoughts as an open-source project. Loopi is a desktop app that lets you build browser automations visually, using a graph-based editor—think drag-and-drop nodes powered by local Puppeteer runs.

**Key features:**

* Drag-and-drop workflow builder for browser actions (inspired by tools like n8n, but tailored for web automation)
* Runs everything locally in Chromium—no cloud or external services needed
* Supports data extraction, variables, conditionals, and loops
* Aimed at simplifying repetitive web tasks without writing code

It's built with Electron, React, TypeScript, Puppeteer, and ReactFlow, fully open-source under MIT.

This is early days (v1.0.0 just dropped), so expect some rough edges—docs are basic, and I'm iterating based on real feedback. If you've used Selenium, Playwright, or similar for testing/scraping, does a visual approach like this solve any pain points for you?

**Example workflow:** Pulling prices from multiple product pages, filtering for deals under $50, then screenshotting matches—all via nodes, no noscripting.

Check it out if it sounds relevant:

* GitHub repo: [https://github.com/Dyan-Dev/loopi](https://github.com/Dyan-Dev/loopi)
* Quick docs: [https://loopi.dyan.live/](https://loopi.dyan.live/)
* Release notes: [https://github.com/Dyan-Dev/loopi/releases/tag/v1.0.0](https://github.com/Dyan-Dev/loopi/releases/tag/v1.0.0)

What browser automation challenges do you face in your projects? Feature ideas, bugs, or contributions (docs/examples/code) would be super helpful. Open to discussing how it stacks up against existing OSS tools!

https://redd.it/1peam4c
@r_opensource

Open-source library of prompts for professional journaling.

Yesterday while scrolling the Journaling channel, I saw a post where users were exchanging prompts. Some of them inspired me later on during my journaling session.

Since the beginning of the year, I've picked up journaling but for my professional environment (we can call it reflective practice) and I've collected a bunch of prompts over the past months.

I thought it would be a good idea to share those prompts in an open-source library where anyone can benefit from them and also submit their own prompts.

For whoever might be interested, here's the page where you can see them and the open-source github repo.

I just created it yesterday so I still have a bunch of prompts and reflection templates to add there.

Hope you find value in some of them!

https://redd.it/1pec4jv
@r_opensource

Can we build WeChat Mini Apps using open web standards?
http://dmathewwws.com/antler-an-irl-browser

https://redd.it/1peewyc
@r_opensource

Built a super simple, stateless, free, Secret Santa generator
https://www.turbosanta.com

https://redd.it/1pefx5x
@r_opensource

terminator: playwright for windows computer use
https://www.useterminator.com

https://redd.it/1pee6id
@r_opensource

Open-Source Data Engine for Context Engineering

Hey everyone,

We are building CocoIndex \- ultra performant data transformation for AI and Context Engineering.

CocoIndex is great for context engineering in ever-changing requirement. Whenever source data or logic change, you don’t need to worry about handling the change and it automatically does incremental processing to keep target fresh. No DSL, just Python.

Here are 20 examples you can build with it and all open sourced - https://cocoindex.io/docs/examples. 


Would love your feedback and we are looking for contributors! Super friendly community. 

Thanks!

https://redd.it/1pejt8g
@r_opensource

I created a leaderboard of the most cracked open source developers

Built a leaderboard for folks to showcase their github contributions and be matched up against other developers, I assume there's some really cracked engineers on this subreddit so if anyone would like to join the leaderboard or rank other devs feel free to do so.

https://devleaderboard.com/leaderboard


https://redd.it/1pemddh
@r_opensource

Vllama: CLI based Framework to run vision models in local and remote GPUs

Hello all, this is my first post. I have built a simple CLI tool, which can help all to run the llms, vision models like image and video gen, models in the local system and if the system doesn't have the gpu or sufficient ram, they can also run it using kaggle's gpu(which is 30 hrs free for a week).

This is inspired from Ollama, which made downloading llms easy and interacting with it much easy, so I thought of why can't this be made for vision models, so I tried this first on my system, basic image generation is working but not that good, then I thought, why can't we use the Kaggle's GPU to generate videos and images and that can happen directly from the terminal with a single step, so that everyone can use this, so I built this VLLAMA.

In this, currently there are many features, like image, video generation in local and kaggles gpu session; download llms and make it run and also interact with it from anywhere (inspired by ollama) also improved it further by creating a vs code extension VLLAMA, using which you can chat directly from the vs code's chat section, users can chat with the local running llm with just adding "@vllama" at the start of the message and this doesn't use any usage cost and can be used as much as anyone wants, you can check this out at in the vscode extensions.

I want to implement this further so that the companies or anyone with gpu access can download the best llms for their usage and initialize it in their gpu servers, and can directly interact with it from the vscode's chat section and also in further versions, I am planning to implement agentic features so that users can use the local llm to use for code editing, in line suggestions, so that they don't have to pay for premiums and many more.

Currently it also has simple Text-to-Speech, and Speech-to-Text, which I am planning to include in the further versions, using open source audio models and also in further, implement 3D generation models, so that everyone can leverage the use of the open models directly from their terminal, and making the complex process of the using open models easy with just a single command in the terminal.

I have also implemented simple functionalities which can help, like listing the downloaded models and their sizes. Other things available are, basic dataset preprocessing, and training ML models directly with just two commands by just providing it the dataset. This is a basic implementation and want to further improve this so that users with just a dataset can clean and pre-process the data, train the models in their local or using the kaggle's or any free gpu providing services or their own gpus or cloud provided gpus, and can directly deploy the models and can use it any cases.

Currently this are the things it is doing and I want to improve such that everyone can use this for any case of the AI and leveraging the use of open models.

Please checkout the work at: https://github.com/ManvithGopu13/Vllama

Published version at: https://pypi.org/project/vllama/

Also the extension: https://marketplace.visualstudio.com/items?itemName=ManvithGopu.vllama

I would appreciate your time for reading and thankful for everyone who want to contribute and spread a word of it.

Please leave your requests for improvements and any suggestions, ideas, and even roasts or anything in the comments or in the issues, this is well taken and appreciated. Thanks in advance. If you find the project useful, kindly contribute and can star it.



https://redd.it/1penhp2
@r_opensource

Submitted my FOSS Privacy focused app that protect files from apps that require storgae or all file access permission.

Hey Everyone,

I'm developer of Seek Privacy android app, a week ago has published it on Fdroid it's in last step of being merged.

The app could feel like vault app but the purpose to build it was not to secure, hide, encrypt files but to protect any type of files from apps with storage access.

Like we download many apps from playstore with internet access, to function they require different storage access permissions. We could ignore few apps but the apps we need to use we are forced to give those permissions. I always felt insecure what these internet connected apps on playstore could be doing I not wanted to just trust them. So I wanted to let them have all files permission so I could use them, but still they never get to touch specific files on storage but I could still access these files normally.

The app is diff from other vault like apps, cause I tried to implement ease of use alongside privacy, which I felt I lacked in other foss apps. So data is removed from external storage and encrypted, but we still could easily access, open, share it using the SeekPrivacy app.

New updates will include categorization for more ease of use and thumbnail to preview the stored file.

Any feedback on the concept is welcome! Excited to contribute to FOSS and Privacy community.

GitHub link : https://github.com/duckniii/SeekPrivacy

https://redd.it/1peq2sx
@r_opensource

Combining Kubescape with ARMO CADR Effective or Overkill

Comparing Kubescape vs ARMO CADR for cloud security. CADR’s runtime monitoring seems to complement Kubescape’s scanning. Thoughts on integrating both in workflows?

https://redd.it/1pepvh1
@r_opensource

I built a productivity app with one rule: if it's not scheduled, it won't get done

I built a personal productivity app based on a controversial belief: unscheduled tasks don't get done. They sit in "someday/maybe" lists forever, creating guilt while you ignore them.

So I made something stricter than GTD. No inbox. No weekly review. Just daily accountability.

## How it works: Two panes

https://imgur.com/a/a2rCTBw

Left pane (Thoughts): Your journal. Write anything as it comes - notes, ideas, tasks. Chronological, like a diary.

Right pane (Time): Your timeline. The app extracts all time-sensitive items from your thoughts and puts them in a schedule.

You can be messy in your thinking (left), but your commitments are crystal clear (right).

## The forcing function: Daily Review

Every morning, the Time pane shows Daily Review - all your undone items from the past. You must deal with each one:

- ✓ Mark done (if you forgot)
- ↷ Reschedule
- × Cancel permanently

If you keep rescheduling something, you'll see "10 days old" staring at you. Eventually you either do it or admit you don't care.

Daily accountability, not weekly. No escape.

## Natural language scheduling

t buy milk at 5pm
t call mom Friday 2pm
e team meeting from 2pm to 3pm

Type it naturally. The app parses the time and schedules it automatically.

The key: When you write a task, you schedule it right then. The app forces you to answer "when will you do this?" You can't skip it.

## Two viewing modes

- Infinite scroll: See 30 days past/future at once
- Book mode: One day per page, flip like a journal

## My stance

If something matters enough to write down, it matters enough to schedule. No "I'll prioritize later." Either:
- Do it now (IRL)
- Schedule it for a specific time
- Don't write it down

This isn't for everyone. It's for people who know unscheduled work doesn't get done and want daily accountability instead of weekly reviews.

## Why I'm posting

I've used this daily for months and it changed how I work. But I don't know if this philosophy resonates with anyone else.

Is "schedule it or don't write it" too strict? Do you also believe unscheduled tasks are just guilt generators? Or am I solving a problem only I have?

If this resonates, I'll keep improving it. It's open source, no backend, local storage only.

GitHub: https://github.com/sawtdakhili/Thoughts-Time

Would love honest feedback on both the philosophy and execution.


https://redd.it/1pesd80
@r_opensource

GitHub - artcore-c/email-xray: Chrome extension to detect hidden text in email
https://github.com/artcore-c/email-xray

https://redd.it/1pev0cj
@r_opensource

Using OpnForm?

I’ve been tracking OpnForm for a while and recently had a chance to chat one-on-one with its creator, Julien Nahum. We dove into the early decisions, AWESOME growth hacks, and cool future plans for the project — here’s the actual recorded convo if you’re curious.

But here’s where I need help:

Are any of you using OpnForm in production for more advanced or large-scale form use cases? Any unexpected blockers, gotchas, etc? He mentioned it was iframe embedded vs natively embedded. Honest opinions encouraged.

https://redd.it/1peyj43
@r_opensource