How to fix software that keeps crashing across Windows and macOS

TL;DR

Software is unstable across multiple platforms, with random crashes, unresponsive apps, and erratic behavior. The key takeaway is that open source projects and native approaches can offer more stable experiences, while platforms like Mac OS and iOS face systemic issues that affect reliability. Stability comes from simpler, well-supported tools and proactive maintenance. These patterns explain why some apps feel reliable while others do not.

Transcript

Have you noticed that software kind of sucks right now? Like in the most literal sense. When I use Windows, I never know if my computer is going to crash randomly when I open a file. My desktop started having an SSD disconnect randomly. iOS is a total mess. I can't even edit a message until it's verified that it sent and done a fancy little animati... Read More

Key Insights

• Software reliability is inconsistent across platforms, leading to frequent crashes and unpredictable behavior.
• Open source projects can be more reliable when driven by small teams with strong community support.
• Stable software often shares common traits: local operation, fast iteration, and transparent maintenance.
• Platform issues on macOS and iOS can degrade user experience due to reduced bug bounties and systemic changes.
• Projects built around lighter runtimes (like Zigg and Electron) can offer good performance despite differing tech stacks.
• The video argues against assuming native language or Swift UI fixes all reliability problems.
• Maintenance and funding models influence software stability, with funded, open projects generally faring better.
• User experience improves when developers admit limitations and focus on robust, verifiable features.
• More videos from this channel:
  • How to spot bad open source tutorials and protect projects
  • How to handle AI tool outages and bugs
  • What is GPT-5 and its pricing, context, and features?
• More from this channel: Theo - t3․gg

Questions & Answers

Q: What is causing software to feel unstable across Windows, macOS, and iOS?

Software instability described in the video arises from a combination of factors including frequent updates, varied platform ecosystems, and inconsistent maintenance across apps. The speaker notes crashes, random disconnections, and interface lag as common symptoms, pointing to deeper architectural choices and funding constraints that affect long term reliability. These issues compound across desktop and mobile platforms, creating a sense of systemic decline.

Q: Which software examples are highlighted as relatively stable and why?

The video highlights Ghosty, Lossless Cut, and Helium as relatively stable examples. Ghosty is notable for being fast and local, built around Zig and driven by a single passionate developer. Lossless Cut is an open source tool that efficiently handles lossless edits, and Helium has matured after initial bugs. The stability comes from focused scope, open source collaboration, and practical usability.

Q: How do open source projects contribute to software stability according to the video?

Open source projects contribute to stability by enabling community review, rapid bug fixing, and transparent development. The video emphasizes that many stable projects are open source, driven by small teams or individuals who can respond quickly to issues. This fosters a culture of accountability and continuous improvement, which improves reliability over time compared to some closed ecosystems.

Q: What role does funding and maintenance play in software reliability?

Funding and maintenance significantly influence reliability because they determine how quickly bugs are addressed and whether the project can evolve to meet user needs. The speaker points out that open projects with active funding and community support tend to stay stable as resources allow for timely fixes. Conversely, reduced bug bounty payouts or limited resources can slow or stall corrective work.

Q: Why does the speaker criticize Swift UI and some native approaches?

The speaker argues that Swift UI can lead to messy, unstable code if overused and that some native approaches do not automatically guarantee stability. The critique centers on the idea that architecture decisions, not just language choice, determine performance and reliability. The message is to evaluate tools by actual behavior rather than broad assumptions about native technologies.

Q: What is the main theme linking the examples of Ghosty, Lossless Cut, and Helium?

The main theme is that stable software often emerges from small, focused projects where developers are deeply involved and motivated, frequently choosing lightweight or traditional tech stacks over trendy, heavy solutions. These projects demonstrate that open collaboration, practical design, and responsive maintenance can yield reliable experiences despite diverse tech foundations.

Q: How does the video view the impact of platform changes on reliability?

The video suggests platform changes such as OS updates and altered bug bounty policies can undermine reliability by reducing incentives to fix issues or by introducing compatibility challenges. The speaker notes that even when apps themselves are well-made, external platform issues can cause widespread instability, making the overall user experience seem worse and increasing frustration.

Q: What practical advice does the video imply for users seeking stable software?

Users seeking stability should favor open source, well-supported projects with active maintenance and a clear track record of quick bug fixes. Prefer tools with local operation and straightforward architectures, and be mindful of platform-specific quirks that can degrade reliability. The underlying message is to choose tools built by small, passionate teams or individuals who prioritize lasting usability over complexity.

Summary & Key Takeaways

• Software reliability varies across projects, with open source and passion projects often delivering better stability due to community support and focused design. The video argues that platform fragmentation and quick update cycles contribute to instability, especially on Mac OS and iOS. These dynamics shape user experiences and expectations.

• The creator highlights specific examples like Ghosty, Lossless Cut, and Helium as stable choices, contrasting them with broader platform issues. The discussion emphasizes that not all bugs are equal, and the root causes include architecture choices and maintenance culture.

• A practical takeaway is to favor lightweight, local, or open source tools when possible, rather than heavy, opaque ecosystems. The video also suggests that the stability of software depends on how well developers respond to issues and how sustainable the project is over time.