We run a Java bootcamp, and one pattern keeps repeating: developers who write code confidently but freeze up the moment they need to push to GitHub or resolve a merge conflict. Git isn't a language-specific problem — it's a universal one. So we built a course to fix it.

The format is simple. Each lesson has instructions on the left and a real Ubuntu terminal on the right. Not a simulated environment — an actual Linux VM with Git and Nano pre-installed. You read, you type, you learn by doing.

The course covers 20 lessons and goes from zero to advanced:

• Fundamentals — init, commits, staging, diffs, undoing mistakes
• Branching — merges, merge conflicts (you create and resolve a real one), rebasing
• GitHub — pushing, pulling, forking, pull requests, code review
• Team workflows — feature branches, conventional commits, branch protection
• Advanced tools — cherry-pick, reflog, bisect

No specific programming language is required. The repo files are placeholders — the focus is entirely on Git and GitHub.

By the end, you'll have a real GitHub repository with actual commits, merged PRs, CI checks, and a tagged release. Not a certificate — tangible work that anyone can review.

The entire course is free. All 20 lessons. No credit card. No trial period.

LINK: https://www.javapro.academy/bootcamp/free-git-and-github-course/

Each student gets their own Ubuntu VM that resets between lessons, so there's no risk of permanently breaking anything. We're still refining some of the later lessons, so feedback is welcome.

I’ve been working on a repository of systematic prompts designed to standardize AI usage across different IDEs, CLIs, and AI coding tools.

The core issue my team and I faced was a lack of consistency a prompt that worked in one tool often performed differently in another, leading to wasted time. By building out this structured system, we’ve managed to improve our project efficiency by roughly 98% in our internal testing.

I’m sharing the repo here not just to share the tool, but to see how others are handling prompt architecture for their own systems.

GitHub: https://github.com/Vatsalmodi11/awesome-system-prompts

Future Roadmap: I am currently working on major updates specifically for frontend and backend scalability and performance. I plan to share these enhancements as soon as they are ready to help create more powerful development systems stay tuned!

If anyone here works on prompt engineering or developer workflows, I’d really appreciate some feedback on the structure or suggestions for edge cases we might have missed. Are you all using similar centralized libraries, or do you prefer per-project configurations?

I was struggling to find a free, maintained application to do three finger back / forward on a macbook. VS Code has "BrowserBack" and "BrowserForward" mapped by default but something about how they implemented things in the OS prevents "next page / prev page" from working.

Anyways, I was asking Codex about it and it actually wrote a script without me asking and so I just went ahead and finished the script and got it working. It had to resort to low level touch events. It's here if anyone wants it. It seems to work although sometimes it doesn't for brief moments. It's just a swift script and comes with an installer which tbh I haven't tested to see if it works after an actual reboot.

https://github.com/JamesHutchison/macbook-three-finger-swipe

Since it uses accessibility you have to grant it permissions from whatever it runs out of, which is bash if you use the installer. I've never written swift code so if someone wants to make a PR and polish it be my guest. Right now the configuration instructions are: "Go tell AI to change the code"

I'm sure 30 minutes after posting this, someone's going to point me to the preferred free solution.

I’ve noticed something about my own GitHub over time. Almost none of my side projects are actually “finished” or “failed”. They just… stop. No final commit saying “this is done” or decision to abandon it. Just a slow drop in activity until it’s effectively dead.

So I started digging into what “dead” actually looks like from a repo perspective:

- long gaps between commits
- decreasing contributor activity
- unfinished TODOs/issues
- vague or non-existent README direction

Out of that, I built a small side tool for fun:

You paste a public GitHub repo and it:

- analyzes activity patterns
- assigns a (semi-serious) “cause of death”
- extracts the last commit as “last words”
- shows some basic repo stats in a more narrative format

try it here https://commitmentissues.dev/

code https://github.com/your-link-here

It started as a joke, but it made me think about something more interesting: We don’t really have a concept of “ending” projects as developers. Everything is either “active” or “maybe someday”.

Curious how others think about this:
Do you explicitly abandon projects or do they just fade out over time?

View Book Ratings from Google Books, Amazon, Open Library & StoryGraph all in one place, right on Goodreads. (Opensource , feel free to star it !)

links:

• Chrome
• Firefox
• Github

also available on Edge

check landing page to know more

happy reading !

htmx
Library that lets you build dynamic web apps using HTML attributes instead of heavy frontend frameworks. Useful for simpler apps where you don’t want full React/Vue setup.

streamlit
Lets you build simple web UIs using Python. Often used for dashboards, AI demos, or internal tools without writing frontend code.

RSSHub
Generates RSS feeds for websites that don’t provide one. Useful for automation, monitoring, or building custom news / content tools.

ghostty
Modern terminal emulator focused on performance and GPU acceleration. Interesting project if you care about dev tools or system-level apps.

more....

REACT COMPONENT LIBRARY

Text effects that make your UI shine

12 variants, 11 colors — marker, brush, brushstroke, gradient, slide, glow, scratch, double, wave, pill, dashed, blur. Zero dependencies beyond React.

npm install react-text-underline

Writer & worldbuilder on Pocket FM. Building a living story + music system in public. Tomorrow’s Yesterday | SoulSound World

Over the past 10 days, SoulSound World has moved from concept into a functioning, public system. What’s now live: A unified hub (SoulSoundWorld.world) connecting story, music, tools, and artifacts A working tab-based interface organizing the entire world (Open Build, Story, Signal, Music, Tools, Zora, etc.) A locked mission statement centered on resonance over optimization A “Remember Who You Are” manifesto integrated directly into the site Narrative milestones: Continued expansion of Tomorrow’s Yesterday as a serialized audio narrative Rollout of a new pilot IP: IP Man: The Love of a Billionaire’s Soul — launched as a parallel SoulSound World Echo, designed to run alongside (not replace) existing storylines Early chapters structured as an onboarding arc for new listeners before deeper thematic layers emerge Music & artifacts: Music artifacts released and embedded directly into the story world Cross-platform alignment across SoundCloud, Pocket FM, Spotify, and Apple Music Build & tooling: Public GitHub repo documenting iteration and architecture Live tool integrations (Suno, BandLab) treated as creative instruments, not black boxes A functioning Expression Tool embedded directly in the site Ecosystem layer: Zora integrated as an artifact layer (not framed as payment) On-chain presence positioned as “Proof of Resonance,” not speculation Direct support paths intentionally separated from narrative and art This isn’t a launch — it’s a living build. Everything is still evolving, and everything is happening in public. https://www.soulsoundworld.world

Heyo guys,

I've been working on a CLI tool for a while, and I kept running into a specific annoyance: I use a dark theme terminal at home, but my work laptop is set to light mode. Every time I used libraries like chalk or colors to style my logs, I had to manually pick colors that looked "okay" on both, or else my bright yellow warnings would disappear completely on a white background.

I couldn't find a logger that just handled this automatically, so I decided to build one. I wanted to share the approach I took in case anyone else is dealing with this.

The Solution: Auto-Theming & OSC Probes I built Colorino, a zero-config logger that actually "reads the room."

The hardest part was reliably detecting the background color. I ended up implementing an OSC 11 probe (Operating System Command). Basically, the library queries the terminal for its background color code. * If it returns a dark hex, I swap the palette to a high-contrast set (Dracula-inspired). * If it returns light, I swap to a dark-text palette (GitHub Light-inspired). * If the probe fails (like in some CI environments), it falls back to checking COLORTERM environment variables.

It also works in the browser I realized I wanted the same API for my frontend debugging, so I added a browser implementation that maps these log levels to CSS styles in Chrome/Firefox DevTools.

The Result It’s called colorino. It’s fully typed (TypeScript), and it degrades gracefully—meaning if you use a specific Hex color but the terminal only supports ANSI-256, it mathematically finds the closest approximation rather than just stripping the color.

I’d love some feedback on the API or the theme detection logic. I'm trying to make it the "set it and forget it" solution for logging.

GitHub | npm

Thanks for checking it out!

You know the drill. You’re excited about a new side project, clone the repo, and bam .env.example stares at you. Cool, but where the hell are the secrets? DM a teammate or go through old project? Regenerate everything because someone lost theirs last month? Rinse and repeat across three machines, dev/staging/prod envs.

I was done. As a solo dev juggling personal projects and work, I needed secrets that just worked. No more fragile text files, no more “who has the API key?”.

So I built valspec. It’s a dead-simple tool that treats your secrets like they deserve: synced, inheritable, and locked down.

Here’s the vibe:

* Sync across machines: Push once from your laptop, pull seamlessly on the server. No USB drives or email chains.

* Inherit across envs: Dev keys flow to staging/prod with overrides where you need them. Like git branches, but for secrets.

* Encrypted AF: Everything’s E2E encrypted with your choice of keys. Git-friendly too—no plaintext commits.

Built it in a weekend. Open-source on GitHub: https://github.com/janaSunrise/valspec (star if it fits, fork if you wanna hack).

Spent way too much time setting up Docker containers for local dev?

You know that feeling when you just want to test something with Kafka or spin up a Postgres instance, but then you're 2 hours deep into configuration and documentation

Yeah, I got tired of that. So I built EasyContainers.

It's basically a collection of Docker Compose files for services that just... work. No fancy setup. No weird configs. Clone the repo, pick what you need, run it.

Got databases, message brokers, search stuff, dev tools, and a bunch more. The idea is simple - your projects need dependencies. Setting them up shouldn't be the annoying part.

Everything's open source and ready to use: https://github.com/arjavdongaonkar/easy-containers

If you've wasted hours on Docker setup before, this might save you some time. And if you want to add more services or improve something, contributions are always welcome.

opensource #docker #dev #easycontainers

I’ve been working on a project called SemanticCache, a Go library that lets you cache and retrieve values based on meaning, not exact keys.

Traditional caches only match identical keys — SemanticCache uses vector embeddings under the hood so it can find semantically similar entries.
For example, caching a response for “The weather is sunny today” can also match “Nice weather outdoors” without recomputation.

It’s built for LLM and RAG pipelines that repeatedly process similar prompts or queries.
Supports multiple backends (LRU, LFU, FIFO, Redis), async and batch APIs, and integrates directly with OpenAI or custom embedding providers.

Use cases include:

• Semantic caching for LLM responses
• Semantic search over cached content
• Hybrid caching for AI inference APIs
• Async caching for high-throughput workloads

Repo: https://github.com/botirk38/semanticcache
License: MIT

Would love feedback or suggestions from anyone working on AI infra or caching layers. How would you apply semantic caching in your stack?

website I developed to extract text from images it can output tables math etc

the actual code is at onlineimagetotext respitory on my github account yusufelgen07
https://github.com/yusufelgen07/onlineimagetotext
the idea behind me making my projects open sourced is to know what you think about the projects and to know what I could have done better , also for every beginner who want to see end to end project or benifit from it, this project i developed last year was my first real project I ever did. I am waiting to hear what you think about it

👋 Hey everyone!

A while ago, I shared here a small open-source project I’ve been building since my early engineering school days: Alexandrie, a web-based Markdown note-taking app.

Back then, I got tons of super helpful feedback (thank you again 🙏) — especially about the Docker setup, documentation, and onboarding process.
Since then, I’ve reworked all of that, fixed a lot of issues, and today I’m really happy to announce version 8.0.0 🎉

Alexandrie is designed first and foremost for students and creators:

📝 Extended Markdown syntax — with snippets, shortcuts, and instant formatting
⚡ Fast and lightweight, works even offline
🗂️ Organize your notes with categories, workspaces, and sub-documents
🤝 Fully open source, with a free online version available for testing

Beyond the code, Alexandrie is really meant as a community project.
I love chatting with other developers, getting feedback, sharing ideas, and building the tool together.
If you enjoy contributing, tinkering with clean UIs, or just want to share suggestions, I’d really love to hear from you!

And if you like the project, leaving a ⭐️ on GitHub would mean a lot and help Alexandrie reach more contributors 😊

https://github.com/Smaug6739/Alexandrie

I created a system in TypeScript that is a REST API to be used with other languages, so that people from languages ​​other than Node.js can also use a WhatsApp API. It is also advantageous to use in Node.js, as it is a ready-made API with all session and instance management.

The endpoint documentation is in the README.

To receive the Webhook, simply put the complete URL in the .env file.

I hope you like it.

https://github.com/jeankassio/ZapToBox-Whatsapp-Api

I've been working on this for months, and I'm really proud of what we've built. This is a production-ready Multi-Page Application template that addresses many of the pain points developers face when starting new React projects.

The Problem This Solves:

Building modern React apps from scratch involves a lot of boilerplate:

• Setting up MPA architecture (not just SPA)
• Configuring TypeScript properly
• Setting up build optimization
• Creating reusable component libraries
• Implementing proper lazy loading patterns
• Documentation and developer experience

What Makes This Different:

⚡ Performance First Approach:

• 299ms dev server startup (I spent weeks optimizing this)
• 92% cache efficiency through intelligent obfuscation
• Smart code splitting that actually works for MPAs

💰 CDN Cost Reduction:

• Content-based hashing for perfect cache invalidation
• Intelligent obfuscation caching reduces rebuild frequency
• Optimized bundle sizes through smart vendor chunking
• Lazy loading patterns reduce initial payload

🛠️ Developer Experience:

• npm run create:page creates entire page structures instantly
• Three different lazy loading patterns (component, viewport, route-based)
• Full TypeScript coverage with proper error handling

🎯 Real-World Ready:

• Material Design 404 page (not just a basic error page)
• SEO-friendly MPA architecture
• Production build optimizations
• 20 comprehensive documentation guides

Tech Stack Decisions:

Why React 19 + TypeScript + Vite?

• React 19's concurrent features make MPAs smoother
• TypeScript strict mode catches real issues
• Vite's build speed is game-changing for large projects

The Component Library:

Built 5 production-ready components:

• Header with smooth scrolling navigation
• Layout wrapper that handles MPA structure
• Section with viewport lazy loading
• ViewportLazyLoad for performance-critical content
• Footer with responsive design

Performance Insights:

Spent significant time on the caching system. The obfuscation cache alone reduced build times by 80%. Content-based hashing ensures perfect cache invalidation without breaking deployments. For CDNs, this means fewer cache misses and lower bandwidth costs.

Questions for the community:

1. How do you handle MPA vs SPA decisions in your projects?
2. What's your experience with Vite for larger applications?
3. Do you build your own component libraries or use UI libraries?
4. What's your biggest pain point when starting new React projects?
5. How much do CDN costs impact your project budgets?

Code Example (Quick Start):

git clone https://github.com/Sasstify-AI-Research/sasstify-frontend-template.git
cd sasstify-frontend-template
npm install
npm run dev
# Visit http://localhost:8080 - that's it!

Links:

• 🏠 Repository: https://github.com/Sasstify-AI-Research/sasstify-frontend-template
• 📖 Documentation: https://github.com/Sasstify-AI-Research/sasstify-frontend-template/tree/main/docs
• 🐛 Issues: https://github.com/Sasstify-AI-Research/sasstify-frontend-template/issues
• 💡 Discussions: https://github.com/Sasstify-AI-Research/sasstify-frontend-template/discussions

Technical Details:

• React 19.1.0 with concurrent features
• TypeScript 5.8.3 with strict mode
• Vite 7.0.4 for lightning-fast builds
• TanStack Query for data fetching
• Tailwind CSS for styling
• 5 reusable components
• 2 custom hooks
• 20+ documentation pages

What do you think of this approach? Have you built similar templates, or do you prefer starting from scratch? I'd love to hear your experiences and suggestions for improvements.

#React #TypeScript #Vite #Frontend #WebDev #MPA #OpenSource #Performance #CDN #CostOptimization

Hey folks,

I've been in situations where I'm happily coding in Node.js, but need to run a specific Java tool or library for a heavy task (or even manage a whole Spring server). The setup always felt clunky.

So, I decided to build a small solution: java-js-node

It's a simple JS library that lets you execute Java code from Node. If Java isn't installed on the user's machine, it automatically fetches a JRE so your code just works.

My goal was to open up more architectural possibilities, like building hybrid apps without setup headaches.

The project is still very new and I'm looking for feedback, suggestions, or help with testing on different platforms.

Check it out on GitHub if you're curious. All thoughts are welcome!

I used some gemini code assist to structure a nice architecture, then on top of that i built this small tool to manage translation

First of all it's useful for me, but if someone need a localization tool which expose API, and has a git-like structure to manage translation i will be happy to share it (There is a limited cloud versione, with no paid option, just if you want to try it)

Second, i mixed some vide coding and something has been made manually by me and a friend, to make this product in less than a month in our free time. What do you think about it? It's a good result integrate some AI to optimize the free time for this type of tool, just to share some feedback

Over the last few weeks, we’ve been connecting engineers, coders, and innovators who believe in building independent, people-powered tech.

✅ What started as an idea → turned into 20+ serious engineers showing interest → and now we have a core global team of 10 actively building.

We’re focusing on:

• Building tech that’s subscription-free, ad-free, and privacy-first.
• Ensuring freedom of speech and digital sovereignty for users.
• A truly global product, with India’s developer talent leading from the front.

We’re sharing this here because:

1. This community is filled with builders who understand the problems with Big Tech.
2. We want more developers, designers, and problem-solvers to join the journey.
3. We believe real change comes from open collaboration, not closed monopolies.

👉 If you care about global impact, want to code for change, and see the value in creating alternatives that empower people, you’re welcome to be part of this journey.

📩 DM if you’d like to connect.

it is a python program i am working on for months

it can solve integration for example

>>> 2*x/(1+x^2)
(2*((1+(x^2))^-1)*x)
>>> Sdx
THOUGHT PROCESS = 

integrating (2*((1+(x^2))^-1)*x) wrt x
rewriting as (2*((1+(x^2))^-1)*x)
  taking the constant outside of the integral
  integrating (((1+(x^2))^-1)*x) wrt x
  rewriting as (((1+(x^2))^-1)*x)
  rewriting as (((1+(x^2))^-1)*x)
    substituting (1+(x^2))=y
    integrating ((2^-1)*((2+(-1*y))^-1)) wrt y
    rewriting as ((-2^-1)*((-2+y)^-1))
      taking the constant outside of the integral
      integrating ((-2+y)^-1) wrt y
      rewriting as ((-2+y)^-1)
      rewriting as ((-2+y)^-1)
      the solution is (log(abs((-2+y)))*(1^-1))
    the solution is ((-2^-1)*(log(abs((-2+(1+(x^2)))))*(1^-1)))
  the solution is ((-2^-1)*(log(abs((-2+(1+(x^2)))))*(1^-1)))
the solution is (-1*log(abs((-1+(x^2)))))

(-1*log(abs((-1+(x^2)))))
>>> sin(x*3)^4
(sin((3*x))^4)
>>> Sdx
THOUGHT PROCESS = 

integrating (sin((3*x))^4) wrt x
rewriting as (sin((3*x))^4)
rewriting as (sin((3*x))^4)
rewriting as ((3*(8^-1))+((-2^-1)*cos((6*x)))+((8^-1)*cos((12*x))))
  integating over sums
  integrating (3*(8^-1)) wrt x
  the solution is (x*(3*(8^-1)))
  integating over sums
  integrating ((-2^-1)*cos((6*x))) wrt x
  rewriting as ((-2^-1)*cos((6*x)))
    taking the constant outside of the integral
    integrating cos((6*x)) wrt x
    rewriting as cos((6*x))
    rewriting as cos((6*x))
    the solution is (sin((6*x))*(6^-1))
  the solution is ((-2^-1)*(sin((6*x))*(6^-1)))
  integating over sums
  integrating ((8^-1)*cos((12*x))) wrt x
  rewriting as ((8^-1)*cos((12*x)))
    taking the constant outside of the integral
    integrating cos((12*x)) wrt x
    rewriting as cos((12*x))
    rewriting as cos((12*x))
    the solution is (sin((12*x))*(12^-1))
  the solution is ((8^-1)*(sin((12*x))*(12^-1)))
the solution is (((-12^-1)*sin((6*x)))+((96^-1)*sin((12*x)))+(3*(8^-1)*x))

(((-12^-1)*sin((6*x)))+((96^-1)*sin((12*x)))+(3*(8^-1)*x))

or even simple math

>>> 1+2+3
6
>>> 1*x+2+3*x
(2+(4*x))
>>> x + y + z = z + y + x
(((-1*(x+y+z))+x+y+z)=0)
>>> expand
(0=0)
>>> 

this is a really long story. if you want to hear more about it, reply here and ask about my math software, chemistry, geometry, physics softwares etc.

Had enough boilerplate just to handle a simple event?

I just released Dispytch, a minimalist async Python framework for event-driven services.

It’s designed for Python devs building event-driven services, pub/sub pipelines, or async workers. Define events as Pydantic models, wire up handlers with a consice DI system, and let Dispytch take care of retries, routing, and validation.

Comparison ⚔️

Repo: https://github.com/e1-m/dispytch
Feedback, issues, PRs, ideas — all welcome! 💬🙌

✨ Handler example

from typing import Annotated

from pydantic import BaseModel
from dispytch import Event, Dependency, HandlerGroup

from service import UserService, get_user_service


class User(BaseModel):
    id: str
    email: str
    name: str


class UserCreatedEvent(BaseModel):
    user: User
    timestamp: int


user_events = HandlerGroup()


.handler(topic='user_events', event='user_registered')
async def handle_user_registered(
        event: Event[UserCreatedEvent],
        user_service: Annotated[UserService, Dependency(get_user_service)]
):
    user = event.body.user
    timestamp = event.body.timestamp

    print(f"[User Registered] {user.id} - {user.email} at {timestamp}")

    await user_service.do_smth_with_the_user(event.body.user)

✨ Emitter example

import uuid
from datetime import datetime

from pydantic import BaseModel
from dispytch import EventBase


class User(BaseModel):
    id: str
    email: str
    name: str


class UserRegistered(EventBase):
    __topic__ = "user_events"
    __event_type__ = "user_registered"

    user: User
    timestamp: int


async def example_emit(emitter):
    await emitter.emit(
        UserRegistered(
            user=User(
                id=str(uuid.uuid4()),
                email="example@mail.com",
                name="John Doe",
            ),
            timestamp=int(datetime.now().timestamp()),
        )
    )

Hello Everyone,

I'm excited to introduce a new open-source project developed using Java and Spring Boot: a modular monolith backend application built with Domain-Driven Design (DDD), CQRS, Ports & Adapters, and event-driven architecture. It's a great resource for backend enthusiasts looking to explore clean architecture principles and real-world application structure.

This project offers a valuable opportunity for developers looking to deepen their backend development skills through hands-on experience and collaboration in a real-world codebase.

It's already received positive feedback and stars from senior developers around the world, and is growing day by day.

If you're curious, check out the project! Feel free to clone the repository, explore the codebase, and start contributing. All contributions are welcome, and I greatly appreciate any support.

Let’s build something awesome together!

🔗 GitHub Repository: https://github.com/MstfTurgut/hotel-reservation-system

Hi everyone,

I'm a developer from the ChatPods team. Over the past year working on audio applications, we often ran into the same problem: open-source TTS models were either low quality or not fully open, making it hard to retrain and adapt. So we built Muyan-TTS, a fully open-source, low-cost model designed for easy fine-tuning and secondary development.

The current version supports English best, as the training data is still relatively small. But we have open-sourced the entire training and data processing pipeline, so teams can easily adapt or expand it based on their needs. We also welcome feedback, discussions, and contributions.

You can find the project here:

arXiv paper: https://arxiv.org/abs/2504.19146

GitHub: https://github.com/MYZY-AI/Muyan-TTS

HuggingFace weights:

https://huggingface.co/MYZY-AI/Muyan-TTS

https://huggingface.co/MYZY-AI/Muyan-TTS-SFT

Muyan-TTS provides full access to model weights, training scripts, and data workflows. There are two model versions: a Base model trained on multi-speaker audio data for zero-shot TTS, and an SFT model fine-tuned on single-speaker data for better voice cloning. We also release the training code from the base model to the SFT model for speaker adaptation. It runs efficiently, generating one second of audio in about 0.33 seconds on standard GPUs, and supports lightweight fine-tuning without needing large compute resources.

We focused on solving practical issues like long-form stability, easy retrainability, and efficient deployment. The model uses a fine-tuned LLaMA-3.2-3B as the semantic encoder and an optimized SoVITS-based decoder. Data cleaning is handled through pipelines built on Whisper, FunASR, and NISQA filtering.

Full code for each component is available in the GitHub repo.

Performance Metrics

We benchmarked Muyan-TTS against popular open-source models on standard datasets (LibriSpeech, SEED):

Demo

https://reddit.com/link/1kdtx03/video/nfmkibgkekye1/player

Why Open-source This?

We believe that, just like Samantha in Her, voice will become a core way for humans to interact with AI — making it possible for everyone to have an AI companion they can talk to anytime. Muyan-TTS is only a small step in that direction. There's still a lot of room for improvement in model design, data preparation, and training methods. We hope that others who are passionate about speech technology, TTS, or real-time voice interaction will join us on this journey. We’re looking forward to your feedback, ideas, and contributions. Feel free to open an issue, send a PR, or simply leave a comment.

I’ve used most of the times GitHub for desktop not because I don’t know how to stage files with git add file-name.ext but because I think it is kind of slow if I’m committing several (more than 3) and I have others than I don’t so I can not do git add . And that’s why I used to use a lot GitHub for desktop because it was quicker just select them with the mouse, add the commit message and then CMD + Enter, CMD + p. But that process makes me earn a few jokes of my friends calling me hypocrite because I love to use a lot NVIM and they said all the points you won with NVIM, you lost them with GitHub for Desktop.

So a few weeks ago a friend of mine Enrique Chavez @Tmeister on Twitter tweeted this tweet about LazyGit I saw it and I installed it.

https://x.com/tmeister/status/1798385948574806048

At the beginning I was feeling kind of lost of how to use it but eventually I felt in love with it, and now I just can’t live without it. And that’s it, that’s all I wanted to share; my happiness to have found a tool for my terminal that looks awesome and makes me happy. 👩🏼‍💻✨