POPULARITY
Categories
320 episodes with Commodore
214 episodes with Commodore
207 episodes with Commodore
113 episodes with Commodore
85 episodes with Commodore
112 episodes with Commodore
88 episodes with Commodore
170 episodes with Commodore
80 episodes with Commodore
132 episodes with Commodore
88 episodes with Commodore
80 episodes with Commodore
86 episodes with Commodore
120 episodes with Commodore
88 episodes with Commodore
69 episodes with Commodore
35 episodes with Commodore
25 episodes with Commodore
20 episodes with Commodore
64 episodes with Commodore
44 episodes with Commodore
27 episodes with Commodore
16 episodes with Commodore
18 episodes with Commodore
19 episodes with Commodore
22 episodes with Commodore
13 episodes with Commodore
10 episodes with Commodore
15 episodes with Commodore
16 episodes with Commodore
10 episodes with Commodore
24 episodes with Commodore
15 episodes with Commodore
8 episodes with Commodore
7 episodes with Commodore
13 episodes with Commodore
13 episodes with Commodore
9 episodes with Commodore
9 episodes with Commodore
12 episodes with Commodore
16 episodes with Commodore
5 episodes with Commodore
15 episodes with Commodore
8 episodes with Commodore
29 episodes with Commodore
9 episodes with Commodore
18 episodes with Commodore
7 episodes with Commodore
5 episodes with Commodore
7 episodes with Commodore
7 episodes with Commodore
12 episodes with Commodore
3 episodes with Commodore
7 episodes with Commodore
11 episodes with Commodore
9 episodes with Commodore
3 episodes with Commodore
4 episodes with Commodore
107 episodes with Commodore
5 episodes with Commodore
10 episodes with Commodore
4 episodes with Commodore
13 episodes with Commodore
4 episodes with Commodore
10 episodes with Commodore
4 episodes with Commodore
5 episodes with Commodore
5 episodes with Commodore
8 episodes with Commodore
4 episodes with Commodore
4 episodes with Commodore
11 episodes with Commodore
3 episodes with Commodore
13 episodes with Commodore
5 episodes with Commodore
8 episodes with Commodore
2 episodes with Commodore
9 episodes with Commodore
3 episodes with Commodore
6 episodes with Commodore
5 episodes with Commodore
4 episodes with Commodore
4 episodes with Commodore
3 episodes with Commodore
4 episodes with Commodore
9 episodes with Commodore
3 episodes with Commodore
2 episodes with Commodore
2 episodes with Commodore
7 episodes with Commodore
2 episodes with Commodore
9 episodes with Commodore
3 episodes with Commodore
2 episodes with Commodore
3 episodes with Commodore
2 episodes with Commodore
6 episodes with Commodore
4 episodes with Commodore
6 episodes with Commodore
AI Assisted Coding: From Deterministic to AI-Driven—The New Paradigm of Software Development, With Markus Hjort In this BONUS episode, we dive deep into the emerging world of AI-assisted coding with Markus Hjort, CTO of Bitmagic. Markus shares his hands-on experience with what's being called "vibe coding" - a paradigm shift where developers work more like technical product owners, guiding AI agents to produce code while focusing on architecture, design patterns, and overall system quality. This conversation explores not just the tools, but the fundamental changes in how we approach software engineering as a team sport. Defining Vibecoding: More Than Just Autocomplete "I'm specifying the features by prompting, using different kinds of agentic tools. And the agent is producing the code. I will check how it works and glance at the code, but I'm a really technical product owner." Vibecoding represents a spectrum of AI-assisted development approaches. Markus positions himself between pure "vibecoding" (where developers don't look at code at all) and traditional coding. He produces about 90% of his code using AI tools, but maintains technical oversight by reviewing architectural patterns and design decisions. The key difference from traditional autocomplete tools is the shift from deterministic programming languages to non-deterministic natural language prompting, which requires an entirely different way of thinking about software development. The Paradigm Shift: When AI Changed Everything "It's a different paradigm! Looking back, it started with autocomplete where Copilot could implement simple functions. But the real change came with agentic coding tools like Cursor and Claude Code." Markus traces his journey through three distinct phases. First came GitHub Copilot's autocomplete features for simple functions - helpful but limited. Next, ChatGPT enabled discussing architectural problems and getting code suggestions for unfamiliar technologies. The breakthrough arrived with agentic tools like Cursor and Claude Code that can autonomously implement entire features. This progression mirrors the historical shift from assembly to high-level languages, but with a crucial difference: the move from deterministic to non-deterministic communication with machines. Where Vibecoding Works Best: Knowing Your Risks "I move between different levels as I go through different tasks. In areas like CSS styling where I'm not very professional, I trust the AI more. But in core architecture where quality matters most, I look more thoroughly." Vibecoding effectiveness varies dramatically by context. Markus applies different levels of scrutiny based on his expertise and the criticality of the code. For frontend work and styling where he has less expertise, he relies more heavily on AI output and visual verification. For backend architecture and core system components, he maintains closer oversight. This risk-aware approach is essential for startup environments where developers must wear multiple hats. The beauty of this flexibility is that AI enables developers to contribute meaningfully across domains while maintaining appropriate caution in critical areas. Teaching Your Tools: Making AI-Assisted Coding Work "You first teach your tool to do the things you value. Setting system prompts with information about patterns you want, testing approaches you prefer, and integration methods you use." Success with AI-assisted coding requires intentional configuration and practice. Key strategies include: System prompts: Configure tools with your preferred patterns, testing approaches, and architectural decisions Context management: Watch context length carefully; when the AI starts making mistakes, reset the conversation Checkpoint discipline: Commit working code frequently to Git - at least every 30 minutes, ideally after every small working feature Dual AI strategy: Use ChatGPT or Claude for architectural discussions, then bring those ideas to coding tools for implementation Iteration limits: Stop and reassess after roughly 5 failed iterations rather than letting AI continue indefinitely Small steps: Split features into minimal increments and commit each piece separately In this segment we refer to the episode with Alan Cyment on AI Assisted Coding, and the Pachinko coding anti-pattern. Team Dynamics: Bigger Chunks and Faster Coordination "The speed changes a lot of things. If everything goes well, you can produce so much more stuff. So you have to have bigger tasks. Coordination changes - we need bigger chunks because of how much faster coding is." AI-assisted coding fundamentally reshapes team workflows. The dramatic increase in coding speed means developers need larger, more substantial tasks to maintain flow and maximize productivity. Traditional approaches of splitting stories into tiny tasks become counterproductive when implementation speed increases 5-10x. This shift impacts planning, requiring teams to think in terms of complete features rather than granular technical tasks. The coordination challenge becomes managing handoffs and integration points when individuals can ship significant functionality in hours rather than days. The Non-Deterministic Challenge: A New Grammar "When you're moving from low-level language to higher-level language, they are still deterministic. But now with LLMs, it's not deterministic. This changes how we have to think about coding completely." The shift to natural language prompting introduces fundamental uncertainty absent from traditional programming. Unlike the progression from assembly to C to Python - all deterministic - working with LLMs means accepting probabilistic outputs. This requires developers to adopt new mental models: thinking in terms of guidance rather than precise instructions, maintaining checkpoints for rollback, and developing intuition for when AI is "hallucinating" versus producing valid solutions. Some developers struggle with this loss of control, while others find liberation in focusing on what to build rather than how to build it. Code Reviews and Testing: What Changes? "With AI, I spend more time on the actual product doing exploratory testing. The AI is doing the coding, so I can focus on whether it works as intended rather than syntax and patterns." Traditional code review loses relevance when AI generates syntactically correct, pattern-compliant code. The focus shifts to testing actual functionality and user experience. Markus emphasizes: Manual exploratory testing becomes more important as developers can't rely on having written and understood every line Test discipline is critical - AI can write tests that always pass (assert true), so verification is essential Test-first approach helps ensure tests actually verify behavior rather than just existing Periodic test validation: Randomly modify test outputs to verify they fail when they should Loosening review processes to avoid bottlenecks when code generation accelerates dramatically Anti-Patterns and Pitfalls to Avoid Several common mistakes emerge when developers start with AI-assisted coding: Continuing too long: When AI makes 5+ iterations without progress, stop and reset rather than letting it spiral Skipping commits: Without frequent Git checkpoints, recovery from AI mistakes becomes extremely difficult Over-reliance without verification: Trusting AI-generated tests without confirming they actually test something meaningful Ignoring context limits: Continuing to add context until the AI becomes confused and produces poor results Maintaining traditional task sizes: Splitting work too granularly when AI enables completing larger chunks Forgetting exploration: Reading about tools rather than experimenting hands-on with your own projects The Future: Autonomous Agents and Automatic Testing "I hope that these LLMs will become larger context windows and smarter. Tools like Replit are pushing boundaries - they can potentially do automatic testing and verification for you." Markus sees rapid evolution toward more autonomous development agents. Current trends include: Expanded context windows enabling AI to understand entire codebases without manual context curation Automatic testing generation where AI not only writes code but also creates and runs comprehensive test suites Self-verification loops where agents test their own work and iterate without human intervention Design-to-implementation pipelines where UI mockups directly generate working code Agentic tools that can break down complex features autonomously and implement them incrementally The key insight: we're moving from "AI helps me code" to "AI codes while I guide and verify" - a fundamental shift in the developer's role from implementer to architect and quality assurance. Getting Started: Experiment and Learn by Doing "I haven't found a single resource that covers everything. My recommendation is to try Claude Code or Cursor yourself with your own small projects. You don't know the experience until you try it." Rather than pointing to comprehensive guides (which don't yet exist for this rapidly evolving field), Markus advocates hands-on experimentation. Start with personal projects where stakes are low. Try multiple tools to understand their strengths. Build intuition through practice rather than theory. The field changes so rapidly that reading about tools quickly becomes outdated - but developing the mindset and practices for working with AI assistance provides durable value regardless of which specific tools dominate in the future. About Markus Hjort Markus is Co-founder and CTO of Bitmagic, and has over 20 years of software development expertise. Starting with Commodore 64 game programming, his career spans gaming, fintech, and more. As a programmer, consultant, agile coach, and leader, Markus has successfully guided numerous tech startups from concept to launch. You can connect with Markus Hjort on LinkedIn.
Will Byrum and Trevor Hulan are joined by former Vanderbilt offensive lineman and legend Blake Fromang to recap and break down Vanderbilt's first loss of the season. The Commodores came up short in Tuscaloosa against the #10 Crimson Tide 30-14. Will, Trevor, and Blake give their 3 key takeaways from the game and then go on to answer premium message board questions. Take the bye week Commodore nation - rest up, reload, and get ready for the final 6 games of the 2025 season.Let's have ourselves a Wednesday
From flop sweat to faux pas, job interviews offer a wealth of scenarios to sell everything from deodorant to diet soda. Plus, a law firm gets creative with their marketing, a it's JINGLE TIIIIIIIME! Here are links to the ads we talked about in this week's show: Pepsi Max - Job Interview https://www.youtube.com/watch?v=LVCYmO1agUM Schick Xtreme 3 - Job Interview https://www.ispot.tv/ad/7F3E/schick-xtreme-3-interview A&W Rootbeer - Dumb Ass https://youtu.be/tMe3WDmxBEI?si=c4OOvCkhGiVH6jU3 Bud Light - Lazy Job Interview https://youtu.be/-BesTv5qQsk?si=3yB6lA1O_2BlrS8- Austin Plumbing, Heating, Air & Electric https://youtu.be/40q2HRVz4Zw?si=VluE2zSlsoD7WHZT Old Spice - Five Year Plan - Job Interview https://www.ispot.tv/ad/ADjH/old-spice-smell-em-five-year-plan Commodore 64 Commercial - Job Interview (November 20, 1983) https://youtu.be/Yhof9VyrFuA?si=m5bnuBKmrAbC5cLx Pardons Direct - Job Interview https://youtu.be/n_ynlcjdqj0?si=YZccPNaNLhke-Vq2 Tide Stick - Talking Stain https://www.youtube.com/watch?v=Ocurs9KLC0Q Haverty's - Job Interview https://youtu.be/fK3tPcfZ3aY?si=e4u6zSLBfw5RLCC9 Morgan & Morgan - Bouncer https://youtu.be/iDM5Hcd1lhU?si=pIFkEGUEBI0ST5sd Honeycomb - A Big Bing Bite https://youtu.be/N75uiGlvIbI?si=F29lBu4W0Zq0m6jC
We're back for Episode 163 of Pixel Gaiden!In this episode the boys catch up on what they've been playing and adding to their collections + 1988 cutesy arcade battle. Taito's New Zealand Story. VS Marchen Maze by Namco. 11:48- Quick Questions43:26 - Patreon48:26 - Eric's Take - Mods That Saved The System1:09:14 - Pairings Game Show1:42:36 - Catching Up3:10:20 - 1988 Cutesy Arcade Battle. Taito's New Zealand Story. VS Marchen Maze by Namco. Please give us a review on Apple Podcasts!Thanks for listening!You can always reach us at podcast@pixelgaiden.com. Send us an email if we missed anything in the show notes you need. You can now support us on Patreon. Thank you to Roy Fielding, Daniel James, 10MARC, Eric Sandgren, Brian Arsenault, Retro Gamer Nation, Maciej Sosnowski, Paradroyd, RAM OK ROM OK, Mitsoyama, David Vincent, Ant Stiller, Mr. Toast, Jason Holland, Mark Scott, Vicky Lamburn, Mark Richardson, Scott Partelow, Paul Jacobson, Steve Rasmussen, Steve Rasmussen's Mom, Retro Gamer Nation, Peter Price, Brett Alexander, Jason Warnes, Josh Malone (48kram), AndrewSan, Jochwat, John Shawler, and Adam from Commodore Chronicles for making this show possible through their generous donation to the show. Support our sponsor Retro Rewind for all of your Commodore needs! Use our page at https://retrorewind.ca/pixelgaiden and our discount code PG10 for 10%
We're back for Episode 163 of Pixel Gaiden! In this episode the boys catch up on what they've been playing and adding to their collections + 1988 cutesy arcade battle. Taito's New Zealand Story. VS Marchen Maze by Namco. 11:48- Quick Questions 43:26 - Patreon 48:26 - Eric's Take - Mods That Saved The System 1:09:14 - Pairings Game Show 1:42:36 - Catching Up 3:10:20 - 1988 Cutesy Arcade Battle. Taito's New Zealand Story. VS Marchen Maze by Namco. Please give us a review on Apple Podcasts! Thanks for listening! You can always reach us at podcast@pixelgaiden.com. Send us an email if we missed anything in the show notes you need. You can now support us on Patreon. Thank you to Roy Fielding, Daniel James, 10MARC, Eric Sandgren, Brian Arsenault, Retro Gamer Nation, Maciej Sosnowski, Paradroyd, RAM OK ROM OK, Mitsoyama, David Vincent, Ant Stiller, Mr. Toast, Jason Holland, Mark Scott, Vicky Lamburn, Mark Richardson, Scott Partelow, Paul Jacobson, Steve Rasmussen, Steve Rasmussen's Mom, Retro Gamer Nation, Peter Price, Brett Alexander, Jason Warnes, Josh Malone (48kram), AndrewSan, Jochwat, John Shawler, and Adam from Commodore Chronicles for making this show possible through their generous donation to the show. Support our sponsor Retro Rewind for all of your Commodore needs! Use our page at https://retrorewind.ca/pixelgaiden and our discount code PG10 for 10%
Vanderbilt Football head coach Clark Lea joins Commodore Hour to recap Utah State and preview Alabama. Listen to the Commodores and Crimson Tide this weekend on the Vanderbilt Sports Network from Learfield. Available on 94.9 The Fan in Nashville. Always streaming on the Vanderbilt Athletics app.See Privacy Policy at https://art19.com/privacy and California Privacy Notice at https://art19.com/privacy#do-not-sell-my-info.
נוסטלגיה.תחושת הגעגוע לעבר וש"פעם היה יותר טוב".זוכרים שפעם הכל היה פשוט יותר? בלי התמכרות לטלפון, ילדים צייצו ברחובות וציפורים צחקו על העצים.הדור של היום מתקשה בלהשקיע מספיק בקשרים בין אישיים, אנחנו מוצפים בפרסומות מכל עבר וטרנדים באים והולכים כל שבוע. פעם היינו משחקים ברחוב או במקרה הטוב יושבים עם כל החברים ביחד בסלון ומשחקים בקונסולה ביחד.המחשב היה כלי עבודה ולא כלי בידור. המסך ריצד, המודם צפצף ומקשי המקלדת הרעישו במיוחד.זוכרים את הימים הטובים מול ה Commodore 64?מה לגבי משחק עם חבר על ה Atari?או עבודה במשרד על ה Apple II?אחחחח הימים הטובים. חלקנו זוכרים. ואם אתם כבר לא, הבאנו מרואיין שהתחביב שלו הוא לשחזר מחשבים ישנים, זכרונות ישנים ובמקרה שלכם - את זכרונות הילדות שלכם.ולצעירים שביניכם - אפשר לקבל תחושת נוסטלגיה גם על תקופה שקדמה להגיעכם לאוויר העולם.המרואיין שלנו הפעם הוא ענבר רז, VP Research בחברת Zenity ובזמנו הלא פנוי יש לו תחביב יותר ייחודי מפודקאסטר:הוא משחזר מחשבים ישנים ומחזיר אותם לתפקוד מלא!קיבלנו המלצה חמה מדניאל גולדברג לראיין את ענבר והוא הלך All-in והזמין אותנו לראות את האוסף הפרטי שלו של מחשבי רטרו משוחזרים - חלקם במצב תקין ומסוגלים להריץ קוד כמו פעם, חלקם בדרך לשם, וחלקם לעד יישארו זיכרון מתוק.אז על מה דיברנו?- מה הופך מחשב לרטרו?- איך משחזרים מחשב ישן שחלקי החילוף שלו לא קיימים יותר?- אילו באגים יש במחשבי רטרו?- איך מתמודדים עם חוסר תאימות בין ציוד הבדיקה של היום לממשקים של פעם?- מהם השינויים הארכיטקטוניים של מחשבים לאורך השנים?- חדשות מפתיעות על הקומודור!למי שלא יודע, לענבר יש בלוג מומלץ על רטרו מחשבים בשם Unarmed Retro:https://www.retro.unarmedsecurity.net/והוא הרצה בכנס BlueHat השנה:https://www.youtube.com/watch?v=71CzXr1FFds אחרי שהאזנתם לפרק מוזמנים להצטרף לקבוצת המאזינים שלנו - שם אנחנו אהבנו מחשבים ישנים לפני שזה היה מגניב >>>https://chat.whatsapp.com/KwUu8pQsxx220qS7AXv04Tמוזמנים ליצור איתנו קשר במייל podcasthardreset@gmail.com
Wir sprechen mit Martin Gutenbrunner, der in Linz eine kleine C128-Sammlung hat und einen Youtube-Kanal betreibt.
In the month of January 1992 many games were released for the Commodore 64. In episode two-hundred of Zapped to the Past, we continue our look at some of those games, including the rock-em sock-em Final Blow, the somnambulistic Sleepwalker, and the blurry Toki, and celebrate a whole lot at the fact we made it to two hundred episodes! Games covered in this episode: Toki Final Blow The Cycles Sleepwalker Find us here: https://zappedtothepast.com/ If you would like to help us out and join our Patreon, find it here: https://www.patreon.com/zappedtothepast If you want to buy a Coffee for Zapped to the Past, go here: https://ko-fi.com/zappedtothepast Need our links in one place - you can do that too: https://linktr.ee/zappedtothepast https://online.pubhtml5.com/oowg/grrx/#p=1 Our Amazing Contributors can be found here: https://www.youtube.com/@bastichb64k https://retroasylum.com/ https://fusionretrobooks.com/collections/retro-books https://c64books.co.uk/ Additional links mentioned in the Podcast: https://www.lemon64.com/doc/toki/615 https://www.lemonamiga.com/games/docs.php?id=636 https://www.youtube.com/watch?v=VI_MBT0GQrQ https://www.youtube.com/watch?v=PcvozN0Oj5o https://www.youtube.com/watch?v=z8LVQTTO8tc https://www.youtube.com/watch?v=ydtq3Y9QjNU https://www.youtube.com/watch?v=eQsTv3Blul4 https://www.youtube.com/watch?v=qrn6GcDMHBY https://www.youtube.com/watch?v=iquhCuzy1uw https://www.youtube.com/watch?v=1Gg0Fm4ZY80 https://www.youtube.com/watch?v=Z5fAWpv_axs https://www.youtube.com/watch?v=7NrLBlw9WZE https://www.youtube.com/watch?v=1jNNwbuDXsA https://www.youtube.com/watch?v=TbqifZMFNdc https://www.youtube.com/watch?v=ggJYJ9frSl0 https://www.youtube.com/watch?v=fECE5FGNaGI https://www.youtube.com/watch?v=dAeYqAQqhps https://www.youtube.com/watch?v=V8AzokCPgsY https://www.youtube.com/watch?v=x4sl861EihQ https://www.youtube.com/watch?v=yU1knfz15xI https://www.youtube.com/watch?v=hGI2d31M7Ns https://www.youtube.com/watch?v=HJfiDFvH3g0 https://www.youtube.com/watch?v=MkSUQYX0ggs https://www.youtube.com/watch?v=8TfgjHwZP0Y https://www.youtube.com/watch?v=74ecvPrqwXw https://www.youtube.com/watch?v=IgoA4emdUqw https://www.youtube.com/watch?v=ib01_vWRpx0 https://www.youtube.com/watch?v=v2hU_ehQ1eI https://www.youtube.com/watch?v=5WO8kUYv5iI https://www.youtube.com/watch?v=Flsebs8SlgA https://www.youtube.com/watch?v=yaZWCGs7tFw https://www.youtube.com/watch?v=FyOnxPc1VdM https://www.youtube.com/watch?v=ICWiaZvB_IY https://www.youtube.com/watch?v=plP-ekxhN7E https://www.youtube.com/watch?v=LXCrkY5WNA0 https://www.youtube.com/watch?v=YCYaALgW80c https://www.youtube.com/watch?v=vdVKcTmFVkw https://www.youtube.com/watch?v=M04qMom2wrM https://www.youtube.com/watch?v=yDtTVYHOBZI https://www.youtube.com/watch?v=wXZUW7O6pv0 https://www.youtube.com/watch?v=QxM42rG0a08 https://www.youtube.com/watch?v=FgKXBJ2LZKo https://www.youtube.com/watch?v=x-HgSE3MkEc https://www.youtube.com/watch?v=rgSEqeDQyPI https://www.youtube.com/watch?v=FoeYA4TmAcc https://www.youtube.com/watch?v=7pEfCe1-KTw https://www.lemon64.com/doc/cycles-international-grand-prix-racing/835
It's time for the tenth episode of the SceneSat edition of the Chip SID Show! All tracks recorded from the original 6581 and 8580 SID Chips, directly from the rear end of the Commodore 64 home computer.
Enjoying the podcast? Tell us what you think below and give us a review or rating. As always we'd love to hear your suggestions and feedback. Send us an email: podcast@pensionbee.com. University has never been more expensive. A 2025 report from the Higher Education Policy Institute found that students need £61,000 to have a minimum socially acceptable standard of living over a three-year degree. But even the maximum annual Maintenance Loan available to students from the lowest income households would only cover half this. So who's expected to plug the gap: the students or their parents? Join our host, Philippa Lamb, and our expert panel as they discuss the financial realities new students are facing and how parents can support their children through university. Communications Director at Save the Student, Tom Allingham; Founder of Pennies to Pounds, Kia Commodore; and Engineering Manager at PensionBee, Stewart Twynham. Episode Breakdown: 04:10 What are Tuition and Maintenance Loans? 07:11 How families can navigate university costs 10:54 The impact of household income 15:18 Is university good value for money? 18:15 Price of a pint across the UK 20:28 Can students supplement costs with part-time jobs? 22:00 Should parents pay for their kids to go to university? 23:51 Financial health check for parents 28:04 How can student finance be improved? Further reading, listening and watching: To learn more about supporting students at university, check out these articles, podcasts and videos from PensionBee: Episode 42 transcript (Blog) E41: How can multi-generational living save you money? (Podcast) E28: The Bank of Mum and Dad - what's the impact on your pension? (Podcast) 5 tips for parents paying for university (Blog) Building your family's financial resilience (Video) Is it better to pay off your student loan or top up your pension? (Blog) Retirement planning in your 50s (Article) Should you pay off your child's student loan? (Blog) Starting a pension at 50 (Blog) Other useful resources: Changes to tuition fees: 2025 to 2026 academic year (GOV.UK) Mapped: The price of a pint across the UK (The Independent) Parents' guide to university 2025 (Save the Student) Student finance for undergraduates (GOV.UK) Student living costs in the UK 2025 (Save the Student) Student Money Survey 2024 Results (Save the Student) The impact of undergraduate degrees on lifetime earnings (IFS) The UK Pension Landscape (PensionBee) Catch up on the latest news, read our transcripts or watch on YouTube: The Pension Confident Podcast The Pension Confident Podcast on YouTube Follow PensionBee (@PensionBee) on TikTok, YouTube, Instagram, LinkedIn, Facebook, X and Threads. Follow Save The Student (@SaveTheStudent) on TikTok, YouTube, Instagram, LinkedIn, Facebook and X. Follow the Pennies To Pounds (@penniestopound) on TikTok, YouTube, Instagram, LinkedIn, Facebook and X.
¡Pixel Perfect Videojuegos, tu programa de radio de ninguna radio, presenta el episodio 115 (26/09/2025)!¡Semana intensa con el State of Play, el Tokyo Game Show y muchas noticias! Síguenos en YouTube (@elpixelpodcast), TikTok y Patreon (audio 320kbps antes que nadie). Gracias a nuestra pedazo de comunidad y a todos los Patreons que lo hacen posible. ¡Suscríbete y activa la campanita para no perderte nada!En Lo Más Fresco repasamos el último State of Play, con dos grandes protagonistas: Wolverine de Insomniac, un juego violento, cinematográfico y espectacular previsto para otoño de 2026, y Saros de Housemarque, heredero directo de Returnal con toda su acción frenética. Además, novedades de Gran Turismo 7, Battlefield 6, Crimson Desert y otros third party destacados.Y también en Made in Japan nos detenemos en el Tokyo Game Show 2025. Capcom presentó Onimusha: Way of the Sword, Pragmata, Monster Hunter Stories 3 y Mega Man Star Force Legacy Collection. Microsoft respondió con Forza Horizon 6 en Japón, Flight Simulator 2024, Age of Mythology y Ninja Gaiden 4. Además, destacamos Call of Duty Black Ops 7, 007 First Light y mucho más.En Noticias hablamos de la nueva subida de precio de Xbox en EE.UU., el tráiler de OD de Hideo Kojima, los lanzamientos de septiembre como Borderlands 4, Silent Hill f y Ghost of Yotei, así como las preventas de las ROG Xbox Ally. También repasamos titulares como el regreso de Commodore, el éxito de Hades II, Sonic Racing CrossWorlds, Yakuza Kiwami 3 o Katana Dragon, un RPG español con referencias muy nuestras.Y en Quemando Controles compartimos a qué estamos jugando: Shinobi Art of Vengeance, Mafia 2 y 3, Ryse Son of Rome y Road 96, con un repaso especial a su narrativa interactiva y a cómo combina aventura gráfica, decisiones y un gran componente musical.Como siempre, cerramos leyendo vuestros comentarios y reaccionando en directo.
Enjoy our annual Gamescom special episode, this time containing all the interviews an trailers including game play material, B-Roll and a presentation of the latest physical boxes for limited runs, as well as Nodepond's Mixed Reality Theatre presentation, it is all in here! over 4 hours of incredible entertainment of what is coming till Christmas 2025 and 2026 for the (retro) gaming enthusiast! AAA, indie, hardware, mixed reality and physical releases? We've got you covered! The interviews start at minute 1:10:30
Sam Altman Redefines AGI, Google's Unified OS, and Windows 10 Updates: Hashtag Trending In this episode of Hashtag Trending, Jim Love discusses Sam Altman's new definition of Artificial General Intelligence (AGI) during an event in Berlin, Google's progress on a unified OS for Android and PC, and the extension of Windows 10 support in Europe. Additionally, the return of the Commodore 64 and its impressive sales, and Bill Gates' acknowledgment of the contribution of Indian engineers to Microsoft's early success are covered. Don't miss out on the latest tech trends and stories! Also, get the latest on Elisa, Jim Love's new sci-fi audiobook. 00:00 Introduction and Sponsor Message 00:39 Sam Altman and the New Definition of AGI 03:49 Google's Unified Android for PC 05:00 Windows 10 Extended Support in Europe 06:35 Commodore 64's Comeback 08:03 Bill Gates on Indian Engineers at Microsoft 09:33 Conclusion and Final Thoughts
Will Byrum and Trevor Hulan are joined by Vanderbilt basketball legend and 4x NBA champion Will Perdue for a bonus episode of TDR. Will and Trevor talk to Will Perdue about his time at Vanderbilt, why West End is special to him, his relationship with Mark Byington, the Nashville Basketball Initiative, building support for the program, and more. Will's passion for Vanderbilt is evident and fans will love listening to him discuss the past and future of Commodore basketball.You can follow the Nashville Basketball initiative on X @NashvilleNBI and you can follow Will Perdue on X @Will_Perdue32
ANTIC Episode 121 - Dongle Disaster In this episode of ANTIC The Atari 8-Bit Computer Podcast… Special guest Brent Carroll joins as we bring you the Atari news and narrowly avoid disaster with our dongle talk … READY! Recurring Links Floppy Days Podcast AtariArchives.org AtariMagazines.com Kay's Book “Terrible Nerd” New Atari books scans at archive.org ANTIC feedback at AtariAge Atari interview discussion thread on AtariAge Interview index: here ANTIC Facebook Page AHCS Eaten By a Grue Next Without For What we've been up to CX40+ Wireless Joystick: https://atari.com/products/wireless-cx40-joystick-atari https://www.amazon.com/Deep-Silver-Wireless-Joystick-Atari-2600/dp/B0DDR68ZXR Harry Stewart died: his daughter sent me documents https://bsky.app/profile/savetz.bsky.social/post/3lyj77tjtns2j Kay's 2017 interview with Harry - ANTIC Interview 295 - Harry Stewart, Pilot and WSFN VCFMW - https://www.vcfwm.org Video interview of Cynthia Solomon and Brian Silverman - https://youtu.be/lWmXPEyl9T8 FujiNet-enabled Atari800Macx: https://forums.atariage.com/topic/382899-adding-fujinet-support-to-atari800macx/page/3/#findComment-5709456 https://github.com/atarimacosx/Atari800MacX/releases/tag/Release_6.1.0Beta1 News Nick DiMasi (SCAT) passed way: Interview with Nick at VCFMW 13 - https://ataripodcast.libsyn.com/antic-the-atari-8-bit-podcast-episode-5-connect-your-atari-to-a-pc (Nick's interview is near the end of the show) SCAT - http://www.scatarians.org/ Rare sighting of a working 1027 printer at latest TACO meeting - https://www.facebook.com/share/v/16vmTRRzHD/ Modified Atari 800 with a custom cpu board and a hp 1611a logic analyzer would plug into the external port - https://www.facebook.com/share/p/1Fv8FM9yxz/ RM800XL update on X - https://x.com/rm_800xl/status/1964665547821637818 Microsoft open-sources the 6502 BASIC coded by Bill Gates himself: https://www.theregister.com/2025/09/04/microsoft_open_sources_6502_basic/ https://github.com/microsoft/BASIC-M6502 Atari XL/XE -=Elite=- beta version: From AtariTeca - https://www.atariteca.net.pe/2025/09/inesperado-beta-jugable-de-elite.html Saberman Retronews - https://www.youtube.com/watch?v=yi8Fr9XFxKQ Download - https://www.atarimania.com/game-atari-400-800-xl-xe-elite_44548.html 5.25" Floppy Envelope Generator from Pawel “Lexx” Kawka: From Atariteca - https://www.atariteca.net.pe/2025/09/nuevo-generador-de-fundas.html online tool for designing covers - https://ataricovers.com/generator-kopert/?lang=en Cassette Cover Generator Newsletter News September, 2025 issue of Atari Insights - https://www.ataribasics.com ABBUC magazines 162 and special mag 56 - https://www.abbuc.de Upcoming Shows Portland Retro Gaming Expo - October 17-19 - Oregon Convention Center, Portland, OR - https://retrogamingexpo.com/ Vintage Computer Festival Montreal - Jan. 24-25, 2026 - Saint-Jean-sur-Richelieu, QC - https://vcfed.org/vcf-montreal/ Vintage Computer Festival SoCal - February 14-15, 2026 - Hotel Fera Events Center, Orange, CA - vcfsocal.com Indy Classic Computer and Video Game Expo - March 20-22 2026 - Wyndham Indianapolis Airport Hotel, Indianapolis, IN - https://indyclassic.org/ VCF East - April 17-19 2026 - InfoAge Science and History Museums, Wall, NJ - https://vcfed.org/events/vintage-computer-festival-east/ Southern Fried Gaming Expo - July 31-Aug 2 2026 - Atlanta, Ga - https://gameatl.com/ Event page created by Chicago Classic Computing - http://chiclassiccomp.org/events.html Event page created by Floppy Days on Facebook - https://www.facebook.com/VintageComputerShows/ Event page on Floppy Days Website - https://docs.google.com/document/d/e/2PACX-1vSeLsg4hf5KZKtpxwUQgacCIsqeIdQeZniq3yE881wOCCYskpLVs5OO1PZLqRRF2t5fUUiaKByqQrgA/pub YouTube Videos How did the Atari beat the Commodore 64 in Chile thanks to Coelsa? - Frognum - https://www.youtube.com/watch?v=6NW2ZkWQ-nw Atari Now! News and Homebrews, September 2025 - Into the Vertical Blank - https://www.youtube.com/watch?v=TKlmVrEHhhI Atari 800XL FujiNet and Sega Genesis Retro.Link Networking Test - Greg Gallardo - https://www.youtube.com/watch?v=VdYFlnNGm9o New at Archive.org Ted Skrecky continues uploading XIO3 newsletters - https://archive.org/details/@ted_skrecky https://archive.org/details/de-re-atari-spanish_202508 Listener Feedback O'Shea limestone cave - http://www.oshealtd.com/atari.htm Long Island Gaming Expo in NY - https://liretro.com/
Everyone likes a good, ole fashioned technological achievement in gaming. But what happens when a twisted visionary tries to move that game to a platform that isn't ready for it?!? I'll tell you what happens...you get a REALLY BAD PORT! Join THE BRENT and Amigo Aaron this week as we see what happens when someone decided to STEP OVER THE LINE (of technology) and do what they said couldn't (and shouldn't) be done! Prepare yourself for the lighting speed HARD DRIVIN' on the Commodore 64 and worlds wackiest, and bloodiest, redemption machine - QUAKE: ARCADE EDITION!
Interview with Karl Hornell - C64 Game Developer, Cartoonist, Author Patreon: https://www.patreon.com/FloppyDays Sponsors: 8-Bit Classics Arcade Shopper FutureVision Research Hello, and welcome to episode 155 of the Floppy Days Podcast for September, 2025! I'm Randy Kindig, your host for this podcast, where we talk about the computers that got many of us started in our careers and which still hold a lot of interest for us today. This month, I'm bringing you another interesting interview with someone who at an early age started developing commercial-grade software for the Commodore 64, which started him on an amazing trajectory with his career in software development, cartoonist, and more. His latest efforts include branching out into writing science fiction, which we will also discuss today. The person I'm referring to is Karl Hornell (Her-NELL). It's also an interesting story around how this interview opportunity came to me. I'm not used to getting contacted by an ad agency. This one indicated that their client, Karl, had just recently published a book and was looking for ways to advertise the book. They suggested that Floppy Days would be a great fit based on Karl's background and could be beneficial for both. I was skeptical at first, as I always am when I receive unsolicited, possibly spam email. However, once I researched Karl's background it became clear that he was an accomplished Swedish developer for the C64 back in the day, with some notariety. I felt his background might indeed be of interest to you, the listeners, and so happily agreed to interviewing Karl for the podcast. I hope you enjoy Karl's story and will consider taking a look at his new book. New Acquisitions and What I've Been Up To Atari Bit Byter User Club (ABBUC) - https://www.abbuc.de VCFMW - https://vcfmw.org/ Atari TT030 at Wikipedia - https://en.wikipedia.org/wiki/Atari_TT030 David Anderson's Timex Sinclair sites: https://andertone.com/ https://www.timexsinclair.com/ News Stan Veit's History of the Personal Computer - https://archive.org/details/stan-veits-history-of-the-personal-computer/mode/2up David Greelish's YouTube channel - https://www.youtube.com/@TheComputerHistorian Early chapters (1-9) of Stan Veit's book via audio - https://www.classiccomputing.com/CCPodcasts/Stan_Veit/Stan_Veit.html Floppy Days YouTube channel - https://www.youtube.com/@floppydayspodcast Upcoming Vintage Computer Shows Tandy Assembly - September 26-28 - Courtyard by Marriott Springfield - Springfield, OH - http://www.tandyassembly.com/ Portland Retro Gaming Expo - October 17-19 - Oregon Convention Center, Portland, OR - https://retrogamingexpo.com/ Chicago TI International World Faire - October 25 - Evanston Public Library, Evanston, IL - https://www.chicagotiug.org/home Ami West - November 1-2, Sacramento, CA - https://www.amiwest.net World of Commodore 2025 - December 6-7 - Admiral Inn, Mississauga, Ontario, Canada - https://www.tpug.ca/world-of-commodore/world-of-commodore-2025/ Vintage Computer Festival Montreal - Jan. 24-25, 2026 - Saint-Jean-sur-Richelieu, QC - https://vcfed.org/vcf-montreal/ Vintage Computer Festival SoCal - February 14-15, 2025 - Hotel Fera Events Center, Orange, CA - vcfsocal.com Indy Classic Computer and Video Game Expo - March 20-22 - Wyndham Indianapolis Airport Hotel, Indianapolis, IN - https://indyclassic.org/ Schedule Published on Floppy Days Website - https://docs.google.com/document/d/e/2PACX-1vSeLsg4hf5KZKtpxwUdQgacCIsqeIdQeZniq3yE881wOCCYskpLVs5OO1PZLqRRF2t5fUUiaKByqQrgA/pub Interview Links Karl at Wikipedia - https://en.wikipedia.org/wiki/Karl_H%C3%B6rnell Vic-Rapport Magazine (Wikipedia) - https://sv.wikipedia.org/wiki/VIC-rapport “Generation 64 - How the Commodore 64 Inspired a Generation of Swedish Gamers” by Bitmap Books - https://amzn.to/3YUUlQ5 (affiliate link) Karl Hornell's Applet Center - http://www.javaonthebrain.com/ Retro Gamer Magazine #130 with Karl interview - https://archive.org/details/retro-gamer-raspberry-pi-buenos-aires/Retro%20Gamer%20130/page/92/mode/2up “Singularity Minus Twelve” book - https://amzn.to/3S8Yr3r (affiliate link) Savage Dragonbert - https://wiki.savagedragon.com/comics/savage_dragonbert_full_frontal_nerdity_01/
Everyone likes a good, ole fashioned technological achievement in gaming. But what happens when a twisted visionary tries to move that game to a platform that isn't ready for it?!? I'll tell you what happens...you get a REALLY BAD PORT! Join THE BRENT and Amigo Aaron this week as we see what happens when someone decided to STEP OVER THE LINE (of technology) and do what they said couldn't (and shouldn't) be done! Prepare yourself for the lighting speed HARD DRIVIN' on the Commodore 64 and worlds wackiest, and bloodiest, redemption machine - QUAKE: ARCADE EDITION!
Elizabeth Figura is a Wine developer at Code Weavers. We discuss how Wine and Proton make it possible to run Windows applications on other operating systems. Related links WineHQ Proton Crossover Direct3D MoltenVK XAudio2 Mesa 3D Graphics Library Transcript You can help correct transcripts on GitHub. Intro [00:00:00] Jeremy: Today I am talking to Elizabeth Figuera. She's a wine developer at Code Weavers. And today we're gonna talk about what that is and, uh, all the work that goes into it. [00:00:09] Elizabeth: Thank you Jeremy. I'm glad to be here. What's Wine [00:00:13] Jeremy: I think the first thing we should talk about is maybe saying what Wine is because I think a lot of people aren't familiar with the project. [00:00:20] Elizabeth: So wine is a translation layer. in fact, I would say wine is a Windows emulator. That is what the name originally stood for. it re implements the entire windows. Or you say win 32 API. so that programs that make calls into the API, will then transfer that code to wine and and we allow that Windows programs to run on, things that are not windows. So Linux, Mac, os, other operating systems such as Solaris and BSD. it works not by emulating the CPU, but by re-implementing every API, basically from scratch and translating them to their equivalent or writing new code in case there is no, you know, equivalent. System Calls [00:01:06] Jeremy: I believe what you're doing is you're emulating system calls. Could you explain what those are and, and how that relates to the project? [00:01:15] Elizabeth: Yeah. so system call in general can be used, referred to a call into the operating system, to execute some functionality that's built into the operating system. often it's used in the context of talking to the kernel windows applications actually tend to talk at a much higher level, because there's so much, so much high level functionality built into Windows. When you think about, as opposed to other operating systems that we basically, we end up end implementing much higher level behavior than you would on Linux. [00:01:49] Jeremy: And can you give some examples of what some of those system calls would be and, I suppose how they may be higher level than some of the Linux ones. [00:01:57] Elizabeth: Sure. So of course you have like low level calls like interacting with a file system, you know, created file and read and write and such. you also have, uh, high level APIs who interact with a sound driver. [00:02:12] Elizabeth: There's, uh, one I was working on earlier today, called XAudio where you, actually, you know, build this bank of of sounds. It's meant to be, played in a game and then you can position them in various 3D space. And the, and the operating system in a sense will, take care of all of the math that goes into making that work. [00:02:36] Elizabeth: That's all running on your computer and. And then it'll send that audio data to the sound card once it's transformed it. So it sounds like it's coming from a certain space. a lot of other things like, you know, parsing XML is another big one. That there's a lot of things. The, there, the, the, the space is honestly huge [00:02:59] Jeremy: And yeah, I can sort of see how those might be things you might not expect to be done by the operating system. Like you gave the example of 3D audio and XML parsing and I think XML parsing in, in particular, you would've thought that that would be something that would be handled by the, the standard library of whatever language the person was writing their application as. [00:03:22] Jeremy: So that's interesting that it's built into the os. [00:03:25] Elizabeth: Yeah. Well, and languages like, see it's not, it isn't even part of the standard library. It's higher level than that. It's, you have specific libraries that are widespread but not. Codified in a standard, but in Windows you, in Windows, they are part of the operating system. And in fact, there's several different, XML parsers in the operating system. Microsoft likes to deprecate old APIs and make new ones that do the same thing very often. [00:03:53] Jeremy: And something I've heard about Windows is that they're typically very reluctant to break backwards compatibility. So you say they're deprecated, but do they typically keep all of them still in there? [00:04:04] Elizabeth: It all still It all still works. [00:04:07] Jeremy: And that's all things that wine has to implement as well to make sure that the software works as well. [00:04:14] Jeremy: Yeah. [00:04:14] Elizabeth: Yeah. And, and we also, you know, need to make it work. we also need to implement those things to make old, programs work because there is, uh, a lot of demand, at least from, at least from people using wine for making, for getting some really old programs, working from the. Early nineties even. What people run with Wine (Productivity, build systems, servers) [00:04:36] Jeremy: And that's probably a good, thing to talk about in terms of what, what are the types of software that, that people are trying to run with wine, and what operating system are they typically using? [00:04:46] Elizabeth: Oh, in terms of software, literally all kinds, any software you can imagine that runs on Windows, people will try to run it on wine. So we're talking games, office software productivity, software accounting. people will run, build systems on wine, build their, just run, uh, build their programs using, on visual studio, running on wine. people will run wine on servers, for example, like software as a service kind of things where you don't even know that it's running on wine. really super domain specific stuff. Like I've run astronomy, software, and wine. Design, computer assisted design, even hardware drivers can sometimes work unwind. There's a bit of a gray area. How games are different [00:05:29] Jeremy: Yeah, it's um, I think from. Maybe the general public, or at least from what I've seen, I think a lot of people's exposure to it is for playing games. is there something different about games versus all those other types of, productivity software and office software that, that makes supporting those different. [00:05:53] Elizabeth: Um, there's some things about it that are different. Games of course have gotten a lot of publicity lately because there's been a huge push, largely from valve, but also some other companies to get. A lot of huge, wide range of games working well under wine. And that's really panned out in the, in a way, I think, I think we've largely succeeded. [00:06:13] Elizabeth: We've made huge strides in the past several years. 5, 5, 10 years, I think. so when you talk about what makes games different, I think, one thing games tend to do is they have a very limited set of things they're working with and they often want to make things run fast, and so they're working very close to the me They're not, they're not gonna use an XML parser, for example. [00:06:44] Elizabeth: They're just gonna talk directly as, directly to the graphics driver as they can. Right. And, and probably going to do all their own sound design. You know, I did talk about that XAudio library, but a lot of games will just talk directly as, directly to the sound driver as Windows Let some, so this is a often a blessing, honestly, because it means there's less we have to implement to make them work. when you look at a lot of productivity applications, and especially, the other thing that makes some productivity applications harder is, Microsoft makes 'em, and They like to, make a library, for use in this one program like Microsoft Office and then say, well, you know, other programs might use this as well. Let's. Put it in the operating system and expose it and write an API for it and everything. And maybe some other programs use it. mostly it's just office, but it means that office relies on a lot of things from the operating system that we all have to reimplement. [00:07:44] Jeremy: Yeah, that's somewhat counterintuitive because when you think of games, you think of these really high performance things that that seem really complicated. But it sounds like from what you're saying, because they use the lower level primitives, they're actually easier in some ways to support. [00:08:01] Elizabeth: Yeah, certainly in some ways, they, yeah, they'll do things like re-implement the heap allocator because the built-in heap allocator isn't fast enough for them. That's another good example. What makes some applications hard to support (Some are hard, can't debug other people's apps) [00:08:16] Jeremy: You mentioned Microsoft's more modern, uh, office suites. I, I've noticed there's certain applications that, that aren't supported. Like, for example, I think the modern Adobe Creative Suite. What's the difference with software like that and does that also apply to the modern office suite, or is, or is that actually supported? [00:08:39] Elizabeth: Well, in one case you have, things like Microsoft using their own APIs that I mentioned with Adobe. That applies less, I suppose, but I think to some degree, I think to some degree the answer is that some applications are just hard and there's, and, and there's no way around it. And, and we can only spend so much time on a hard application. I. Debugging things. Debugging things can get very hard with wine. Let's, let me like explain that for a minute because, Because normally when you think about debugging an application, you say, oh, I'm gonna open up my debugger, pop it in, uh, break at this point, see what like all the variables are, or they're not what I expect. Or maybe wait for it to crash and then get a back trace and see where it crashed. And why you can't do that with wine, because you don't have the application, you don't have the symbols, you don't have your debugging symbols. You don't know anything about the code you're running unless you take the time to disassemble and decompile and read through it. And that's difficult every time. It's not only difficult, every time I've, I've looked at a program and been like, I really need to just. I'm gonna just try and figure out what the program is doing. [00:10:00] Elizabeth: It takes so much time and it is never worth it. And sometimes you have to, sometimes you have no other choice, but usually you end up, you ask to rely on seeing what calls it makes into the operating system and trying to guess which one of those is going wrong. Now, sometimes you'll get lucky and it'll crash in wine code, or sometimes it'll make a call into, a function that we don't implement yet, and we know, oh, we need to implement that function. But sometimes it does something, more obscure and we have to figure out, well, like all of these millions of calls it made, which one of them is, which one of them are we implementing incorrectly? So it's returning the wrong result or not doing something that it should. And, then you add onto that the. You know, all these sort of harder to debug things like memory errors that we could make. And it's, it can be very difficult and so sometimes some applications just suffer from those hard bugs. and sometimes it's also just a matter of not enough demand for something for us to spend a lot of time on it. [00:11:11] Elizabeth: Right. [00:11:14] Jeremy: Yeah, I can see how that would be really challenging because you're, like you were saying, you don't have the symbols, so you don't have the source code, so you don't know what any of this software you're supporting, how it was actually written. And you were saying that I. A lot of times, you know, there may be some behavior that's wrong or a crash, but it's not because wine crashed or there was an error in wine. [00:11:42] Jeremy: so you just know the system calls it made, but you don't know which of the system calls didn't behave the way that the application expected. [00:11:50] Elizabeth: Exactly. Test suite (Half the code is tests) [00:11:52] Jeremy: I can see how that would be really challenging. and wine runs so many different applications. I'm, I'm kind of curious how do you even track what's working and what's not as you, you change wine because if you support thousands or tens thousands of applications, you know, how do you know when you've got a, a regression or not? [00:12:15] Elizabeth: So, it's a great question. Um, probably over half of wine by like source code volume. I actually actually check what it is, but I think it's, i, I, I think it's probably over half is what we call is tests. And these tests serve two purposes. The one purpose is a regression test. And the other purpose is they're conformance tests that test, that test how, uh, an API behaves on windows and validates that we are behaving the same way. So we write all these tests, we run them on windows and you know, write the tests to check what the windows returns, and then we run 'em on wine and make sure that that matches. and we have just such a huge body of tests to make sure that, you know, we're not breaking anything. And that every, every, all the code that we, that we get into wine that looks like, wow, it's doing that really well. Nope, that's what Windows does. The test says so. So pretty much any code that we, any new code that we get, it has to have tests to validate, to, to demonstrate that it's doing the right thing. [00:13:31] Jeremy: And so rather than testing against a specific application, seeing if it works, you're making a call to a Windows system call, seeing how it responds, and then making the same call within wine and just making sure they match. [00:13:48] Elizabeth: Yes, exactly. And that is obviously, or that is a lot more, automatable, right? Because otherwise you have to manually, you know, there's all, these are all graphical applications. [00:14:02] Elizabeth: You'd have to manually do the things and make sure they work. Um, but if you write automateable tests, you can just run them all and the machine will complain at you if it fails it continuous integration. How compatibility problems appear to users [00:14:13] Jeremy: And because there's all these potential compatibility issues where maybe a certain call doesn't behave the way an application expects. What, what are the types of what that shows when someone's using software? I mean, I, I think you mentioned crashes, but I imagine there could be all sorts of other types of behavior. [00:14:37] Elizabeth: Yes, very much so. basically anything, anything you can imagine again is, is what will happen. You can have, crashes are the easy ones because you know when and where it crashed and you can work backwards from there. but you can also get, it can, it could hang, it could not render, right? Like maybe render a black screen. for, you know, for games you could very frequently have, graphical glitches where maybe some objects won't render right? Or the entire screen will be read. Who knows? in a very bad case, you could even bring down your system and we usually say that's not wine's fault. That's the graphics library's fault. 'cause they're not supposed to do that, uh, no matter what we do. But, you know, sometimes we have to work around that anyway. but yeah, there's, there's been some very strange and idiosyncratic bugs out there too. [00:15:33] Jeremy: Yeah. And like you mentioned that uh, there's so many different things that could have gone wrong that imagine's very difficult to find. Yeah. And when software runs through wine, I think, Performance is comparable to native [00:15:49] Jeremy: A lot of our listeners will probably be familiar with running things in a virtual machine, and they know that there's a big performance impact from doing that. [00:15:57] Jeremy: How does the performance of applications compare to running natively on the original Windows OS versus virtual machines? [00:16:08] Elizabeth: So. In theory. and I, I haven't actually done this recently, so I can't speak too much to that, but in theory, the idea is it's a lot faster. so there, there, is a bit of a joke acronym to wine. wine is not an emulator, even though I started out by saying wine is an emulator, and it was originally called a Windows emulator. but what this basically means is wine is not a CPU emulator. It doesn't, when you think about emulators in a general sense, they're often, they're often emulators for specific CPUs, often older ones like, you know, the Commodore emulator or an Amiga emulator. but in this case, you have software that's written for an x86 CPU. And it's running on an x86 CPU by giving it the same instructions that it's giving on windows. It's just that when it says, now call this Windows function, it calls us instead. So that all should perform exactly the same. The only performance difference at that point is that all should perform exactly the same as opposed to a, virtual machine where you have to interpret the instructions and maybe translate them to a different instruction set. The only performance difference is going to be, in the functions that we are implementing themselves and we try to, we try to implement them to perform. As well, or almost as well as windows. There's always going to be a bit of a theoretical gap because we have to translate from say, one API to another, but we try to make that as little as possible. And in some cases, the operating system we're running on is, is just better than Windows and the libraries we're using are better than Windows. [00:18:01] Elizabeth: And so our games will run faster, for example. sometimes we can, sometimes we can, do a better job than Windows at implementing something that's, that's under our purview. there there are some games that do actually run a little bit faster in wine than they do on Windows. [00:18:22] Jeremy: Yeah, that, that reminds me of how there's these uh, gaming handhelds out now, and some of the same ones, they have a, they either let you install Linux or install windows, or they just come with a pre-installed, and I believe what I've read is that oftentimes running the same game on both operating systems, running the same game on Linux, the battery life is better and sometimes even the performance is better with these handhelds. [00:18:53] Jeremy: So it's, it's really interesting that that can even be the case. [00:18:57] Elizabeth: Yeah, it's really a testament to the huge amount of work that's gone into that, both on the wine side and on the, side of the graphics team and the colonel team. And, and of course, you know, the years of, the years of, work that's gone into Linux, even before these gaming handhelds were, were even under consideration. Proton and Valve Software's role [00:19:21] Jeremy: And something. So for people who are familiar with the handhelds, like the steam deck, they may have heard of proton. Uh, I wonder if you can explain what proton is and how it relates to wine. [00:19:37] Elizabeth: Yeah. So, proton is basically, how do I describe this? So, proton is a sort of a fork, uh, although we try to avoid the term fork. It's a, we say it's a downstream distribution because we contribute back up to wine. so it is a, it is, it is a alternate distribution fork of wine. And it's also some code that basically glues wine into, an embedding application originally intended for steam, and developed for valve. it has also been used in, others, but it has also been used in other software. it, so where proton differs from wine besides the glue part is it has some, it has some extra hacks in it for bugs that are hard to fix and easy to hack around as some quick hacks for, making games work now that are like in the process of going upstream to wine and getting their code quality improved and going through review. [00:20:54] Elizabeth: But we want the game to work now, when we distribute it. So that'll, that'll go into proton immediately. And then once we have, once the patch makes it upstream, we replace it with the version of the patch from upstream. there's other things to make it interact nicely with steam and so on. And yeah, I think, yeah, I think that's, I got it. [00:21:19] Jeremy: Yeah. And I think for people who aren't familiar, steam is like this, um, I, I don't even know what you call it, like a gaming store and a [00:21:29] Elizabeth: store game distribution service. it's got a huge variety of games on it, and you just publish. And, and it's a great way for publishers to interact with their, you know, with a wider gaming community, uh, after it, just after paying a cut to valve of their profits, they can reach a lot of people that way. And because all these games are on team and, valve wants them to work well on, on their handheld, they contracted us to basically take their entire catalog, which is huge, enormous. And trying and just step by step. Fix every game and make them all work. [00:22:10] Jeremy: So, um, and I guess for people who aren't familiar Valve, uh, softwares the company that runs steam, and so it sounds like they've asked, uh, your company to, to help improve the compatibility of their catalog. [00:22:24] Elizabeth: Yes. valve contracted us and, and again, when you're talking about wine using lower level libraries, they've also contracted a lot of other people outside of wine. Basically, the entire stack has had a tremendous, tremendous investment by valve software to make gaming on Linux work. Well. The entire stack receives changes to improve Wine compatibility [00:22:48] Jeremy: And when you refer to the entire stack, like what are some, some of those pieces, at least at a high level. [00:22:54] Elizabeth: I, I would, let's see, let me think. There is the wine project, the. Mesa Graphics Libraries. that's a, that's another, you know, uh, open source, software project that existed, has existed for a long time. But Valve has put a lot of, uh, funding and effort into it, the Linux kernel in various different ways. [00:23:17] Elizabeth: the, the desktop, uh, environment and Window Manager for, um, are also things they've invested in. [00:23:26] Jeremy: yeah. Everything that the game needs, on any level and, and that the, and that the operating system of the handheld device needs. Wine's history [00:23:37] Jeremy: And wine's been going on for quite a while. I think it's over a decade, right? [00:23:44] Elizabeth: I believe. Oh, more than, oh, far more than a decade. I believe it started in 1990, I wanna say about 1995, mid nineties. I'm, I probably have that date wrong. I believe Wine started about the mid nineties. [00:24:00] Jeremy: Mm. [00:24:00] Elizabeth: it's going on for three decades at this rate. [00:24:03] Jeremy: Wow. Okay. [00:24:06] Jeremy: And so all this time, how has the, the project sort of sustained itself? Like who's been involved and how has it been able to keep going this long? [00:24:18] Elizabeth: Uh, I think as is the case with a lot of free software, it just, it just keeps trudging along. There's been. There's been times where there's a lot of interest in wine. There's been times where there's less, and we are fortunate to be in a time where there's a lot of interest in it. we've had the same maintainer for almost this entire, almost this entire existence. Uh, Alexander Julliard, there was one person starting who started, maintained it before him and, uh, left it maintainer ship to him after a year or two. Uh, Bob Amstat. And there has been a few, there's been a few developers who have been around for a very long time. a lot of developers who have been around for a decent amount of time, but not for the entire duration. And then a very, very large number of people who come and submit a one-off fix for their individual application that they want to make work. [00:25:19] Jeremy: How does crossover relate to the wine project? Like, it sounds like you had mentioned Valve software hired you for subcontract work, but crossover itself has been around for quite a while. So how, how has that been connected to the wine project? [00:25:37] Elizabeth: So I work for, so the, so the company I work for is Code Weavers and, crossover is our flagship software. so Code Weavers is a couple different things. We have a sort of a porting service where companies will come to us and say, can we port my application usually to Mac? And then we also have a retail service where Where we basically have our own, similar to Proton, but you know, older, but the same idea where we will add some hacks into it for very difficult to solve bugs and we have a, a nice graphical interface. And then, the other thing that we're selling with crossover is support. So if you, you know, try to run a certain application and you buy crossover, you can submit a ticket saying this doesn't work and we now have a financial incentive to fix it. You know, we'll try to, we'll try to fix your, we'll spend company resources to fix your bug, right? So that's been so, so code we v has been around since 1996 and crossover, I don't know the date, but it's crossover has been around for probably about two decades, if I'm not mistaken. [00:27:01] Jeremy: And when you mention helping companies port their software to, for example, MacOS. [00:27:07] Jeremy: Is the approach that you would port it natively to MacOS APIs or is it that you would help them get it running using wine on MacOS? [00:27:21] Elizabeth: Right. That's, so that's basically what makes us so unique among porting companies is that instead of rewriting their software, we just, we just basically stick it inside of crossover and, uh, and, and make it run. [00:27:36] Elizabeth: And the idea has always been, you know, the more we implement, the more we get correct, the, the more applications will, you know, work. And sometimes it works out that way. Sometimes not really so much. And there's always work we have to do to get any given application to work, but. Yeah, so it's, it's very unusual because we don't ask companies for any of their code. We don't need it. We just fix the windows API [00:28:07] Jeremy: And, and so in that case, the ports would be let's say someone sells a MacOS version of their software. They would bundle crossover, uh, with their software. [00:28:18] Elizabeth: Right? And usually when you do this, it doesn't look like there's crossover there. Like it just looks like this software is native, but there is soft, there is crossover under the hood. Loading executables and linked libraries [00:28:32] Jeremy: And so earlier we were talking about how you're basically intercepting the system calls that these binaries are making, whether that's the executable or the, the DLLs from Windows. Um, but I think probably a lot of our listeners are not really sure how that's done. Like they, they may have built software, but they don't know, how do I basically hijack, the system calls that this application is making. [00:29:01] Jeremy: So maybe you could talk a little bit about how that works. [00:29:04] Elizabeth: So there, so there's a couple steps to go into it. when you think about a program that's say, that's a big, a big file that's got all the machine code in it, and then it's got stuff at the beginning saying, here's how the program works and here's where in the file the processor should start running. that's, that's your EXE file. And then in your DLL files are libraries that contain shared code and you have like a similar sort of file. It says, here's the entry point. That runs this function, this, you know, this pars XML function or whatever have you. [00:29:42] Elizabeth: And here's this entry point that has the generate XML function and so on and so forth. And, and, then the operating system will basically take the EXE file and see all the bits in it. Say I want to call the pars XML function. It'll load that DLL and hook it up. So it, so the processor ends up just seeing jump directly to this pars XML function and then run that and then return and so on. [00:30:14] Elizabeth: And so what wine does, is it part of wine? That's part of wine is a library, is that, you know, the implementing that parse XML and read XML function, but part of it is the loader, which is the part of the operating system that hooks everything together. And when we load, we. Redirect to our libraries. We don't have Windows libraries. [00:30:38] Elizabeth: We like, we redirect to ours and then we run our code. And then when you jump back to the program and yeah. [00:30:48] Jeremy: So it's the, the loader that's a part of wine. That's actually, I'm not sure if running the executable is the right term. [00:30:58] Elizabeth: no, I think that's, I think that's a good term. It's, it's, it's, it starts in a loader and then we say, okay, now run the, run the machine code and it's executable and then it runs and it jumps between our libraries and back and so on. [00:31:14] Jeremy: And like you were saying before, often times when it's trying to make a system call, it ends up being handled by a function that you've written in wine. And then that in turn will call the, the Linux system calls or the MacOS system calls to try and accomplish the, the same result. [00:31:36] Elizabeth: Right, exactly. [00:31:40] Jeremy: And something that I think maybe not everyone is familiar with is there's this concept of user space versus kernel space. you explain what the difference is? [00:31:51] Elizabeth: So the way I would explain, the way I would describe a kernel is it's the part of the operating system that can do anything, right? So any program, any code that runs on your computer is talking to the processor, and the processor has to be able to do anything the computer can do. [00:32:10] Elizabeth: It has to be able to talk to the hardware, it has to set up the memory space. That, so actually a very complicated task has to be able to switch to another task. and, and, and, and basically talk to another program and. You have to have something there that can do everything, but you don't want any program to be able to do everything. Um, not since the, not since the nineties. It's about when we realized that we can't do that. so the kernel is a part that can do everything. And when you need to do something that requires those, those permissions that you can't give everyone, you have to talk to the colonel and ask it, Hey, can you do this for me please? And in a very restricted way where it's only the safe things you can do. And a degree, it's also like a library, right? It's the kernel. The kernels have always existed, and since they've always just been the core standard library of the computer that does the, that does the things like read and write files, which are very, very complicated tasks under the hood, but look very simple because all you say is write this file. And talk to the hardware and abstract away all the difference between different drivers. So the kernel is doing all of these things. So because the kernel is a part that can do everything and because when you think about the kernel, it is basically one program that is always running on your computer, but it's only one program. So when a user calls the kernel, you are switching from one program to another and you're doing a lot of complicated things as part of this. You're switching to the higher privilege level where you can do anything and you're switching the state from one program to another. And so it's a it. So this is what we mean when we talk about user space, where you're running like a normal program and kernel space where you've suddenly switched into the kernel. [00:34:19] Elizabeth: Now you're executing with increased privileges in a different. idea of the process space and increased responsibility and so on. [00:34:30] Jeremy: And, and so do most applications. When you were talking about the system calls for handling 3D audio or parsing XML. Are those considered, are those system calls considered part of user space and then those things call the kernel space on your behalf, or how, how would you describe that? [00:34:50] Elizabeth: So most, so when you look at Windows, most of most of the Windows library, the vast, vast majority of it is all user space. most of these libraries that we implement never leave user space. They never need to call into the kernel. there's the, there only the core low level stuff. Things like, we need to read a file, that's a kernel call. when you need to sleep and wait for some seconds, that's a kernel. Need to talk to a different process. Things that interact with different processes in general. not just allocate memory, but allocate a page of memory, like a, from the memory manager and then that gets sub allocated by the heap allocator. so things like that. [00:35:31] Jeremy: Yeah, so if I was writing an application and I needed to open a file, for example, does, does that mean that I would have to communicate with the kernel to, to read that file? [00:35:43] Elizabeth: Right, exactly. [00:35:46] Jeremy: And so most applications, it sounds like it's gonna be a mixture. You're gonna have a lot of things that call user space calls. And then a few, you mentioned more low level ones that are gonna require you to communicate with the kernel. [00:36:00] Elizabeth: Yeah, basically. And it's worth noting that in, in all operating systems, you're, you're almost always gonna be calling a user space library. That might just be a thin wrapper over the kernel call. It might, it's gonna do like just a little bit of work in end call the kernel. [00:36:19] Jeremy: [00:36:19] Elizabeth: In fact, in Windows, that's the only way to do it. Uh, in many other operating systems, you can actually say, you can actually tell the processor to make the kernel call. There is a special instruction that does this and just, and it'll go directly to the kernel, and there's a defined interface for this. But in Windows, that interface is not defined. It's not stable. Or backwards compatible like the rest of Windows is. So even if you wanted to use it, you couldn't. and you basically have to call into the high level libraries or low level libraries, as it were, that, that tell you that create a file. And those don't do a lot. [00:37:00] Elizabeth: They just kind of tweak their parameters a little and then pass them right down to the kernel. [00:37:07] Jeremy: And so wine, it sounds like it needs to implement both the user space calls of windows, but then also the, the kernel, calls as well. But, but wine itself does that, is that only in Linux user space or MacOS user space? [00:37:27] Elizabeth: Yes. This is a very tricky thing. but all of wine, basically all of what is wine runs in, in user space and we use. Kernel calls that are already there to talk to the colonel, to talk to the host Colonel. You have to, and you, you get, you get, you get the sort of second nature of thinking about the Windows, user space and kernel. [00:37:50] Elizabeth: And then there's a host user space and Kernel and wine is running all in user, in the user, in the host user space, but it's emulating the Windows kernel. In fact, one of the weirdest, trickiest parts is I mentioned that you can run some drivers in wine. And those drivers actually, they actually are, they think they're running in the Windows kernel. which in a sense works the same way. It has libraries that it can load, and those drivers are basically libraries and they're making, kernel calls and they're, they're making calls into the kernel library that does some very, very low level tasks that. You're normally only supposed to be able to do in a kernel. And, you know, because the kernel requires some privileges, we kind of pretend we have them. And in many cases, you're even the drivers are using abstractions. We can just implement those abstractions kind of over the slightly higher level abstractions that exist in user space. [00:39:00] Jeremy: Yeah, I hadn't even considered the being able to use hardware devices, but I, I suppose if in, in the end, if you're reproducing the kernel, then whether you're running software or you're talking to a hardware device, as long as you implement the calls correctly, then I, I suppose it works. [00:39:18] Elizabeth: Cause you're, you're talking about device, like maybe it's some kind of USB device that has drivers for Windows, but it doesn't for, for Linux. [00:39:28] Elizabeth: no, that's exactly, that's a, that's kind of the, the example I've used. Uh, I think there is, I think I. My, one of my best success stories was, uh, drivers for a graphing calculator. [00:39:41] Jeremy: Oh, wow. [00:39:42] Elizabeth: That connected via USB and I basically just plugged the windows drivers into wine and, and ran it. And I had to implement a lot of things, but it worked. But for example, something like a graphics driver is not something you could implement in wine because you need the graphics driver on the host. We can't talk to the graphics driver while the host is already doing so. [00:40:05] Jeremy: I see. Yeah. And in that case it probably doesn't make sense to do so [00:40:11] Elizabeth: Right? [00:40:12] Elizabeth: Right. It doesn't because, the transition from user into kernel is complicated. You need the graphics driver to be in the kernel and the real kernel. Having it in wine would be a bad idea. Yeah. [00:40:25] Jeremy: I, I think there's, there's enough APIs you have to try and reproduce that. I, I think, uh, doing, doing something where, [00:40:32] Elizabeth: very difficult [00:40:33] Jeremy: right. Poor system call documentation and private APIs [00:40:35] Jeremy: There's so many different, calls both in user space and in kernel space. I imagine the, the user space ones Microsoft must document to some extent, but, oh. Is that, is that a [00:40:51] Elizabeth: well, sometimes, [00:40:54] Jeremy: Sometimes. Okay. [00:40:55] Elizabeth: I think it's actually better now than it used to be. But some, here's where things get fun, because sometimes there will be, you know, regular documented calls. Sometimes those calls are documented, but the documentation isn't very good. Sometimes programs will just sort of look inside Microsoft's DLLs and use calls that they aren't supposed to be using. Sometimes they use calls that they are supposed to be using, but the documentation has disappeared. just because it's that old of an API and Microsoft hasn't kept it around. sometimes some, sometimes Microsoft, Microsoft own software uses, APIs that were never documented because they never wanted anyone else using them, but they still ship them with the operating system. there was actually a kind of a lawsuit about this because it is an antitrust lawsuit, because by shipping things that only they could use, they were kind of creating a trust. and that got some things documented. At least in theory, they kind of haven't stopped doing it, though. [00:42:08] Jeremy: Oh, so even today they're, they're, I guess they would call those private, private APIs, I suppose. [00:42:14] Elizabeth: I suppose. Uh, yeah, you could say private APIs. but if we want to get, you know, newer versions of Microsoft Office running, we still have to figure out what they're doing and implement them. [00:42:25] Jeremy: And given that they're either, like you were saying, the documentation is kind of all over the place. If you don't know how it's supposed to behave, how do you even approach implementing them? [00:42:38] Elizabeth: and that's what the conformance tests are for. And I, yeah, I mentioned earlier we have this huge body of conformance tests that double is regression tests. if we see an API, we don't know what to do with or an API, we do know, we, we think we know what to do with because the documentation can just be wrong and often has been. Then we write tests to figure out what it's supposed to behave. We kind of guess until we, and, and we write tests and we pass some things in and see what comes out and see what. The see what the operating system does until we figure out, oh, so this is what it's supposed to do and these are the exact parameters in, and, and then we, and, and then we implement it according to those tests. [00:43:24] Jeremy: Is there any distinction in approach for when you're trying to implement something that's at the user level versus the kernel level? [00:43:33] Elizabeth: No, not really. And like I, and like I mentioned earlier, like, well, I mean, a kernel call is just like a library call. It's just done in a slightly different way, but it's still got, you know, parameters in, it's still got a set of parameters. They're just encoded differently. And, and again, like the, the way kernel calls are done is on a level just above the kernel where you have a library, that just passes things through. Almost verbatim to the kernel and we implement that library instead. [00:44:10] Jeremy: And, and you've been working on i, I think, wine for over, over six years now. [00:44:18] Elizabeth: That sounds about right. Debugging and having broad knowledge of Wine [00:44:20] Jeremy: What does, uh, your, your day to day look like? What parts of the project do you, do you work on? [00:44:27] Elizabeth: It really varies from day to day. and I, I, a lot of people, a lot of, some people will work on the same parts of wine for years. Uh, some people will switch around and work on all sorts of different things. [00:44:42] Elizabeth: And I'm, I definitely belong to that second group. Like if you name an area of wine, I have almost certainly contributed a patch or two to it. there's some areas I work on more than others, like, 3D graphics, multimedia, a, I had, I worked on a compiler that exists, uh, socket. So networking communication is another thing I work a lot on. day to day, I kind of just get, I, I I kind of just get a bug for some program or another. and I take it and I debug it and figure out why the program's broken and then I fix it. And there's so much variety in that. because a bug can take so many different forms like I described, and, and, and the, and then the fix can be simple or complicated or, and it can be in really anywhere to a degree. [00:45:40] Elizabeth: being able to work on any part of wine is sometimes almost a necessity because if a program is just broken, you don't know why. It could be anything. It could be any sort of API. And sometimes you can hand the API to somebody who's got a lot of experience in that, but sometimes you just do whatever. You just fix whatever's broken and you get an experience that way. [00:46:06] Jeremy: Yeah, I mean, I was gonna ask about the specialized skills to, to work on wine, but it sounds like maybe in your case it's all of them. [00:46:15] Elizabeth: It's, there's a bit of that. it's a wine. We, the skills to work on wine are very, it's a very unique set of skills because, and it largely comes down to debugging because you can't use the tools you normally use debug. [00:46:30] Elizabeth: You have to, you have to be creative and think about it different ways. Sometimes you have to be very creative. and programs will try their hardest to avoid being debugged because they don't want anyone breaking their copy protection, for example, or or hacking, or, you know, hacking in sheets. They want to be, they want, they don't want anyone hacking them like that. [00:46:54] Elizabeth: And we have to do it anyway for good and legitimate purposes. We would argue to make them work better on more operating systems. And so we have to fight that every step of the way. [00:47:07] Jeremy: Yeah, it seems like it's a combination of. F being able, like you, you were saying, being able to, to debug. and you're debugging not necessarily your own code, but you're debugging this like behavior of, [00:47:25] Jeremy: And then based on that behavior, you have to figure out, okay, where in all these different systems within wine could this part be not working? [00:47:35] Jeremy: And I, I suppose you probably build up some kind of, mental map in your head of when you get a, a type of bug or a type of crash, you oh, maybe it's this, maybe it's here, or something [00:47:47] Elizabeth: Yeah. That, yeah, there is a lot of that. there's, you notice some patterns, you know, after experience helps, but because any bug could be new, sometimes experience doesn't help and you just, you just kind of have to start from scratch. Finding a bug related to XAudio [00:48:08] Jeremy: At sort of a high level, can you give an example of where you got a specific bug report and then where you had to look to eventually find which parts of the the system were the issue? [00:48:21] Elizabeth: one, one I think good example, that I've done recently. so I mentioned this, this XAudio library that does 3D audio. And if you say you come across a bug, I'm gonna be a little bit generics here and say you come across a bug where some audio isn't playing right, maybe there's, silence where there should be the audio. So you kind of, you look in and see, well, where's that getting lost? So you can basically look in the input calls and say, here's the buffer it's submitting that's got all the audio data in it. And you look at the output, you look at where you think the output should be, like, that library will internally call a different library, which programs can interact with directly. [00:49:03] Elizabeth: And this our high level library interacts with that is the, give this sound to the audio driver, right? So you've got XAudio on top of, um. mdev, API, which is the other library that gives audio to the driver. And you see, well, the ba the buffer is that XAudio is passing into MM Dev, dev API. They're empty, there's nothing in them. So you have to kind of work through the XAudio library to see where is, where's that sound getting lost? Or maybe, or maybe that's not getting lost. Maybe it's coming through all garbled. And I've had to look at the buffer and see why is it garbled. I'll open up it up in Audacity and look at the weight shape of the wave and say, huh, that shape of the wave looks like it's, it looks like we're putting silence every 10 nanoseconds or something, or, or reversing something or interpreting it wrong. things like that. Um, there's a lot of, you'll do a lot of, putting in print fs basically all throughout wine to see where does the state change. Where was, where is it? Where is it? Right? And then where do things start going wrong? [00:50:14] Jeremy: Yeah. And in the audio example, because they're making a call to your XAudio implementation, you can see that Okay, the, the buffer, the audio that's coming in. That part is good. It, it's just that later on when it sends it to what's gonna actually have it be played by the, the hardware, that's when missing. So, [00:50:37] Elizabeth: We did something wrong in a library that destroyed the buffer. And I think on a very, high level a lot of debugging, wine is about finding where things are good and finding where things are bad, and then narrowing that down until we find the one spot where things go wrong. There's a lot of processes that go like that. [00:50:57] Jeremy: like you were saying, the more you see these problems, hopefully the, the easier it gets to, to narrow down where, [00:51:04] Elizabeth: Often. Yeah. Especially if you keep debugging things in the same area. How much code is OS specific?c [00:51:09] Jeremy: And wine supports more than one operating system. I, I saw there was Linux, MacOS I think free BSD. How much of the code is operating system specific versus how much can just be shared across all of them? [00:51:27] Elizabeth: Not that much is operating system specific actually. so when you think about the volume of wine, the, the, the, vast majority of it is the high level code that doesn't need to interact with the operating system on a low level. Right? Because Windows keeps putting, because Microsoft keeps putting lots and lots of different libraries in their operating system. And a lot of these are high level libraries. and even when we do interact with the operating system, we're, we're using cross-platform libraries or we're using, we're using ics. The, uh, so all these operating systems that we are implementing are con, basically conformed to the posix standard. which is basically like Unix, they're all Unix based. Psic is a Unix based standard. Microsoft is, you know, the big exception that never did implement that. And, and so we have to translate its APIs to Unix, APIs. now that said, there is a lot of very operating system, specific code. Apple makes things difficult by try, by diverging almost wherever they can. And so we have a lot of Apple specific code in there. [00:52:46] Jeremy: another example I can think of is, I believe MacOS doesn't support, Vulkan [00:52:53] Elizabeth: yes. Yeah.Yeah, That's a, yeah, that's a great example of Mac not wanting to use, uh, generic libraries that work on every other operating system. and in some cases we, we look at it and are like, alright, we'll implement a wrapper for that too, on top of Yuri, on top of your, uh, operating system. We've done it for Windows, we can do it for Vulkan. and that's, and then you get the Molten VK project. Uh, and to be clear, we didn't invent molten vk. It was around before us. We have contributed a lot to it. Direct3d, Vulkan, and MoltenVK [00:53:28] Jeremy: Yeah, I think maybe just at a high level might be good to explain the relationship between Direct 3D or Direct X and Vulcan and um, yeah. Yeah. Maybe if you could go into that. [00:53:42] Elizabeth: so Direct 3D is Microsoft's 3D API. the 3D APIs, you know, are, are basically a way to, they're way to firstly abstract out the differences between different graphics, graphics cards, which, you know, look very different on a hardware level. [00:54:03] Elizabeth: Especially. They, they used to look very different and they still do look very different. and secondly, a way to deal with them at a high level because actually talking to the graphics card on a low level is very, very complicated. Even talking to it on a high level is complicated, but it gets, it can get a lot worse if you've ever been a, if you've ever done any graphics, driver development. so you have a, a number of different APIs that achieve these two goals of, of, abstraction and, and of, of, of building a common abstraction and of building a, a high level abstraction. so OpenGL is the broadly the free, the free operating system world, the non Microsoft's world's choice, back in the day. [00:54:53] Elizabeth: And then direct 3D was Microsoft's API and they've and Direct 3D. And both of these have evolved over time and come up with new versions and such. And when any, API exists for too long. It gains a lot of croft and needs to be replaced. And eventually, eventually the people who developed OpenGL decided we need to start over, get rid of the Croft to make it cleaner and make it lower level. [00:55:28] Elizabeth: Because to get in a maximum performance games really want low level access. And so they made Vulcan, Microsoft kind of did the same thing, but they still call it Direct 3D. they just, it's, it's their, the newest version of Direct 3D is lower level. It's called Direct 3D 12. and, and, Mac looked at this and they decided we're gonna do the same thing too, but we're not gonna use Vulcan. [00:55:52] Elizabeth: We're gonna define our own. And they call it metal. And so when we want to translate D 3D 12 into something that another operating system understands. That's probably Vulcan. And, and on Mac, we need to translate it to metal somehow. And we decided instead of having a separate layer from D three 12 to metal, we're just gonna translate it to Vulcan and then translate the Vulcan to metal. And it also lets things written for Vulcan on Windows, which is also a thing that exists that lets them work on metal. [00:56:30] Jeremy: And having to do that translation, does that have a performance impact or is that not really felt? [00:56:38] Elizabeth: yes. It's kind of like, it's kind of like anything, when you talk about performance, like I mentioned this earlier, there's always gonna be overhead from translating from one API to another. But we try to, what we, we put in heroic efforts to. And try, try to make sure that doesn't matter, to, to make sure that stuff that needs to be fast is really as fast as it can possibly be. [00:57:06] Elizabeth: And some very clever things have been done along those lines. and, sometimes the, you know, the graphics drivers underneath are so good that it actually does run better, even despite the translation overhead. And then sometimes to make it run fast, we need to say, well, we're gonna implement a new API that behaves more like windows, so we can do less work translating it. And that's, and sometimes that goes into the graphics library and sometimes that goes into other places. Targeting Wine instead of porting applications [00:57:43] Jeremy: Yeah. Something I've found a little bit interesting about the last few years is [00:57:49] Jeremy: Developers in the past, they would generally target Windows and you might be lucky to get a Mac port or a Linux port. And I wonder, like, in your opinion now, now that a lot of developers are just targeting Windows and relying on wine or, or proton to, to run their software, is there any, I suppose, downside to doing that? [00:58:17] Jeremy: Or is it all just upside, like everyone should target Windows as this common platform? [00:58:23] Elizabeth: Yeah. It's an interesting question. I, there's some people who seem to think it's a bad thing that, that we're not getting native ports in the same sense, and then there's some people who. Who See, no, that's a perfectly valid way to do ports just right for this defacto common API it was never intended as a cross platform common API, but we've made it one. [00:58:47] Elizabeth: Right? And so why is that any worse than if it runs on a different API on on Linux or Mac and I? Yeah, I, I, I guess I tend to, I, that that argument tends to make sense to me. I don't, I don't really see, I don't personally see a lot of reason for, to, to, to say that one library is more pure than another. [00:59:12] Elizabeth: Right now, I do think Windows APIs are generally pretty bad. I, I'm, this might be, you know, just some sort of, this might just be an effect of having to work with them for a very long time and see all their flaws and have to deal with the nonsense that they do. But I think that a lot of the. Native Linux APIs are better. But if you like your Windows API better. And if you want to target Windows and that's the only way to do it, then sure why not? What's wrong with that? [00:59:51] Jeremy: Yeah, and I think the, doing it this way, targeting Windows, I mean if you look in the past, even though you had some software that would be ported to other operating systems without this compatibility layer, without people just targeting Windows, all this software that people can now run on these portable gaming handhelds or on Linux, Most of that software was never gonna be ported. So yeah, absolutely. And [01:00:21] Elizabeth: that's [01:00:22] Jeremy: having that as an option. Yeah. [01:00:24] Elizabeth: That's kind of why wine existed, because people wanted to run their software. You know, that was never gonna be ported. They just wanted, and then the community just spent a lot of effort in, you know, making all these individual programs run. Yeah. [01:00:39] Jeremy: I think it's pretty, pretty amazing too that, that now that's become this official way, I suppose, of distributing your software where you say like, Hey, I made a Windows version, but you're on your Linux machine. it's officially supported because, we have this much belief in this compatibility layer. [01:01:02] Elizabeth: it's kind of incredible to see wine having got this far. I mean, I started working on a, you know, six, seven years ago, and even then, I could never have imagined it would be like this. [01:01:16] Elizabeth: So as we, we wrap up, for the developers that are listening or, or people who are just users of wine, um, is there anything you think they should know about the project that we haven't talked about? [01:01:31] Elizabeth: I don't think there's anything I can think of. [01:01:34] Jeremy: And if people wanna learn, uh, more about the wine project or, or see what you're up to, where, where should they, where should they head? Getting support and contributing [01:01:45] Elizabeth: We don't really have any things like news, unfortunately. Um, read the release notes, uh, follow some, there's some, there's some people who, from Code Weavers who do blogs. So if you, so if you go to codeweavers.com/blog, there's some, there's, there's some codeweavers stuff, uh, some marketing stuff. But there's also some developers who will talk about bugs that they are solving and. And how it's easy and, and the experience of working on wine. [01:02:18] Jeremy: And I suppose if, if someone's. Interested in like, like let's say they have a piece of software, it's not working through wine. what's the best place for them to, to either get help or maybe even get involved with, with trying to fix it? [01:02:37] Elizabeth: yeah. Uh, so you can file a bug on, winehq.org,or, or, you know, find, there's a lot of developer resources there and you can get involved with contributing to the software. And, uh, there, there's links to our mailing list and IRC channels and, uh, and, and the GitLab, where all places you can find developers. [01:03:02] Elizabeth: We love to help you. Debug things. We love to help you fix things. We try our very best to be a welcoming community and we have got a long, we've got a lot of experience working with people who want to get their application working. So, we would love to, we'd love to have another. [01:03:24] Jeremy: Very cool. Yeah, I think wine is a really interesting project because I think for, I guess it would've been for decades, it seemed like very niche, like not many people [01:03:37] Jeremy: were aware of it. And now I think maybe in particular because of the, the Linux gaming handhelds, like the steam deck,wine is now something that a bunch of people who would've never heard about it before, and now they're aware of it. [01:03:53] Elizabeth: Absolutely. I've watched that transformation happen in real time and it's been surreal. [01:04:00] Jeremy: Very cool. Well, Elizabeth, thank you so much for, for joining me today. [01:04:05] Elizabeth: Thank you, Jeremy. I've been glad to be here.
Vanderbilt Football head coach Clark Lea recaps the 70-21 win over Georgia State and looks ahead to Utah State this Saturday. Listen to the Commodores and Aggies on the Vanderbilt Sports Network from Learfield. Available on 102.5 The Game in Nashville and always streaming on the Vanderbilt Athletics app.See Privacy Policy at https://art19.com/privacy and California Privacy Notice at https://art19.com/privacy#do-not-sell-my-info.
Hutt and Chad ask the question is Brian Callahan one of the worst coaches to last more than one season in NFL history? Don't laugh. It's possible. After not knowing that an elbow equals two feet on a catch, his latest gaffe is almost as hysterically incompetent. Plus, Vanderbilt Head Football Coach, Clark Lea joins the show to discuss his teams 4-0 start and what it means for the future of the Commodore program. Learn more about your ad choices. Visit podcastchoices.com/adchoices
In the month of January 1992 many games were released for the Commodore 64. In episode one-hundred-and-ninety-nine of Zapped to the Past, we start our look at some of those games, including samey Super Space Invaders, the catastrophic Cisco Heat and the strategic Stratego and wonder why anyone thought a subscription TV service for solicitors in 1992 was a good idea… Games covered in this episode: Super Space Invaders Cisco Heat Double Dragon 3: The Rosetta Stone Stratego Find us here: https://zappedtothepast.com/ If you would like to help us out and join our Patreon, find it here: https://www.patreon.com/zappedtothepast If you want to buy a Coffee for Zapped to the Past, go here: https://ko-fi.com/zappedtothepast Need our links in one place - you can do that too: https://linktr.ee/zappedtothepast https://online.pubhtml5.com/oowg/grrx/#p=1 Additional links mentioned in the Podcast: https://www.lemonamiga.com/games/docs.php?id=1585 https://www.lemon64.com/doc/stratego/1260
New Game Old Flame - A modern and homebrew retro gaming podcast.
Back together at last, the crew kicks off this episode with a surprisingly heated debate over what really counts as a sandwich—are crackers allowed, does it have to be square, and can you get away with a “convertible” one-slice version? From there, we catch up on life outside the mic: Wiedo finally unveils his custom-built bike and dives into the long-awaited Silksong, Andy thinks about packing in the CRT and moving on to the RetroTINK 4K, and Diego steps out of his gaming backlog long enough to play his first ever bass gig in front of an audience.On the games front, Wiedo brings us the colorful Hungry Huey (Gameboy Color), a demo puzzle gem that mixes Bejeweled-style chaining with slime-feeding chaos, Andy straps in for the roguelike chaos of Blind Jump (Gameboy Advance), and Diego spotlights Emu's Massive Hunt (VIC 20)—a jump-and-collect platformer that proves the little Commodore still has some life in it.
Many are the questions that run through the heads of the Little Snail's award-winning chefs as they are paraded through the streets of Calstega Bay. Some are quite philosophical: When is a victory a failure, and when might imprisonment be protection? Others are more mundane in nature: What is wrong with this Commodore, and how much trouble are we in? They will find answers to some of these questions, certainly, but some answers are only doors to new mysteries and new visions of the world… This week on Perpetua: Sizzling Rivalry, Crashing Waves! 02 Perpetua Guide [In Progress v.04] NPCs & Monsters [PNMS] Hoodlum Mechanic [NMHMC] Typical Traits: Boastful, Irritable, Proud, Strong Stats: DEX 6, INS 6, MIG 10, WLP 8 Attacks: Flash Orb, Heavy Wrench Special Abilities: Field Repair, Electroswing, Bad Temper In-Game Description: Mechanic for the Calstega Bay Cheetahs. You might read “mechanic” and think “brain, not brawn.” But the Cheetah Gang's mechanics are a bit of both. They have giant, electrified wrenches and they know how to use ‘em. That said, they aren't especially hard to hit, so if you're aggressive, you can knock ‘em out before they get the upper handon you. Starter Tip: Make sure to take them out (or at least disable them) before you try to focus on any automatons or constructs, otherwise you'll find that the damage you do gets repaired away! Gangster Killer [NMGKL] Typical Traits: Sneaky, Perceptive, Arrogant, Fast Stats: DEX 8, INS 6, MIG 6, WLP 8 Attacks: Knife Toss, Steel Dagger Special Abilities: None In-Game Description: Cold blooded killer for the Cheetah gang.. These guys are just about the most basic enemy in the game. They do one thing: Damage. They don't have a ton of HP, they don't have a bunch of special moves or spells. They just stab you as hard as they possibly can. Starter Tip: Not much to say, except hope that you don't get dazed by their Knife Toss! Activated BuilderBot [NMABB] Typical Traits: Sneaky, Perceptive, Arrogant, Fast Stats: DEX 8, INS 6, MIG 10, WLP 6 Attacks: Hammer Smash Special Abilities: Barrier Projector In-Game Description: A Calstega Bay Construction bot that has been modified by the Cheetahs. I didn't expect robots to pop up in this game, did you!? If you let a mechanic activate them, they can become a real problem. Not only do they have a really strong melee attack (that can slow you if it hits!) but their Barrier Projector can also prevent the party from fleeing. That said, if you get lucky, you can get one for yourself and use it not only in battles against high-value monsters that flee, but also in some Adventure Field Puzzles, and even in the boss fight at the end of Calstega Bay! Starter Tip: If you can get a BuiilderBot into crisis, it gains the unique “Exposed Core” debuff, losing its fire and ice resistance, but also turning all of its melee damage into Bolt. Hosted by Austin Walker (austinwalker.bsky.social) Featuring Ali Acampora (ali-online.bsky.social), Art Martinez-Tebbel (amtebbel.bsky.social), Jack de Quidt (notquitereal.bsky.social), and Andrew Lee Swan (swandre3000.bsky.social) Produced by Ali Acampora Music by Jack de Quidt (available on bandcamp) Cover Art by Ben McEntee (https://linktr.ee/benmce.art) With thanks to Amelia Renee, Arthur B., Aster Maragos, Bill Kaszubski, Cassie Jones, Clark, DB, Daniel Laloggia, Diana Crowley, Edwin Adelsberger, Emrys, Greg Cobb, Ian O'Dea, Ian Urbina, Irina A., Jack Shirai, Jake Strang, Katie Diekhaus, Ken George, Konisforce, Kristina Harris Esq, L Tantivy, Lawson Coleman, Mark Conner, Mike & Ruby, Muna A, Nat Knight, Olive Perry, Quinn Pollock, Robert Lasica, Shawn Drape, Shawn Hall, Summer Rose, TeganEden, Thomas Whitney, Voi, chocoube, deepFlaw, fen, & weakmint This episode was made with support from listeners like you! To support us, you can go to friendsatthetable.cash.
Our popular series that shines a light on the lesser-spoken-about 8-bit home computers returns with the very underrated Commodore 16 & Plus 4 models. Joining Kingy in this episode are friends of the show, Turnbl & Oblisky who both owned and loved these systems back in the day. Games featured: Kingy's Choices Out on a Limb (Anirog, 1984) — Sam Manthorpe Bongo (Kingsoft, 1986) — Udo Gertz Tom Thumb (Anirog, 1985) — Udo Gertz Tomb of Tarrabash (Audiogenic, 1985) — Mark Sibly Punchy (CBM, 1984) — Evan Parton Turnbl's Choices Fire Ant (CBM, 1984) — David H. Bolton Trailblazer (Mr Chip/Gremlin, 1984) — Shaun Southern Exorcist (CBM/Mr Micro, 1984) — Greg Duddle Treasure Island (CBM/Mr Micro, 1985) — Greg Duddle Speed King (Mr Chip/Mastertronic, 1986) — Shaun Southern Oblisky's Choices Kickstart (Mr Chip, 1986) — Shaun Southern Big Mac (The Mad Maintenance Man) (Mr Chip, 1985) — Tony Kelly Arthur Noid (Mr Chip, 1988) — Shaun Southern Mr Puniverse (Mr Chip, 1986) — Tony Kelly Megabolts (Mr Chip, 1987) — Stuart Cross Show notes: The 264 family of computers - https://www.c64-wiki.com/wiki/Commodore-264_series Plus 4 World - https://plus4world.powweb.com
Colonel James "Fangs" Valpiani knows a thing or two about flight test because he's seen a thing or two: first an Air Force Academy graduate, then a combat-tested F-15E Strike Eagle pilot, a graduate of the French Test Pilot School, and most recently Commodore of the USAF TPS.On this episode, Fangs shares his expertise on the various schools he has attended or led and the aircraft they test, including the X-62 VISTA.Support this podcast at — https://redcircle.com/the-fighter-pilot-podcast/donations
We're back for Episode 162 of Pixel Gaiden!In this episode Cody and Eric catch up on the news and cover 6 Good Stress-Free Games 7:14 - Quick Questions36:57 - Patreon Song42:00- Tea Time With Tim - Tim's adventures in PS3 modding 58:21 - Cody's Corner - Caverns of Mars Recharged1:11:29 - News2:12:19- 6 Good Stress-Free GamesNews notes at pixelgaiden.comPlease give us a review on Apple Podcasts!Thanks for listening!You can always reach us at podcast@pixelgaiden.com. Send us an email if we missed anything in the show notes you need. You can now support us on Patreon. Thank you to Roy Fielding, Daniel James, 10MARC, Eric Sandgren, Brian Arsenault, Retro Gamer Nation, Maciej Sosnowski, Paradroyd, RAM OK ROM OK, Mitsoyama, David Vincent, Ant Stiller, Mr. Toast, Jason Holland, Mark Scott, Vicky Lamburn, Mark Richardson, Scott Partelow, Paul Jacobson, Steve Rasmussen, Steve Rasmussen's Mom, Retro Gamer Nation, Peter Price, Brett Alexander, Jason Warnes, Josh Malone (48kram), AndrewSan, Jochwat, John Shawler, and Adam from Commodore Chronicles for making this show possible through their generous donation to the show. Support our sponsor Retro Rewind for all of your Commodore needs! Use our page at https://retrorewind.ca/pixelgaiden and our discount code PG10 for 10%
We're back for Episode 162 of Pixel Gaiden! In this episode Cody and Eric catch up on the news and cover 6 Good Stress-Free Games 7:14 - Quick Questions 36:57 - Patreon Song 42:00- Tea Time With Tim - Tim's adventures in PS3 modding 58:21 - Cody's Corner - Caverns of Mars Recharged 1:11:29 - News 2:12:19- 6 Good Stress-Free Games News - Tim – Vectrex Mini – Kickstarter coming soon. https://vectrex.com/vectrex-mini-kickstarter/ Eric - Indie Retro News: LittleBigPlanet on the C64? It's certainly possible! https://www.indieretronews.com/2025/08/littlebigplanet-on-c64-its-certainly.html Cody – Evercade Cart News https://evercade.co.uk/cartridges/activision-collection-1/ https://evercade.co.uk/cartridges/llamasoft-collection/ Also Rare Collection – NeoGeo Arcade 2 and 3. Tim – Buzz Bumper on Planet Pinball - Platform / Pinball style new game coming to the Nintendo Gameboy Color. (via Time Extension) https://pearacidic.itch.io/buzz-bumper-on-planet-pinball Cody – Atari Back to school Pack https://atari.com/collections/back-to-school?srsltid=AfmBOopyblji471hCAJ8uwqbhrut-WJfHecFoS4mNik8ZoIMdOv5w8sK Tim -DMG vs. Super Game Boy the first "Super Game Boy exclusive" video game. This experimental game uses a Super Game Boy feature normally "locked away", and that no commercial Game Boy game ever used: the ability to control Super NES sprites in addition to everything moving on the Game Boy screen. (Via Time Extension) https://drludos.itch.io/dmg-vs-super-game-boy Eric - Indie Retro News: Operation Hibernation - A challenging single screen platformer for the ColecoVision and MSX https://www.indieretronews.com/2025/08/operation-hibernation-challenging.html Cody – New Vectrex Stuff! https://www.vectrexmulti.com/order2.html Tim – What If... OutRun on the Gameboy. Sorry guys another version of OutRun to report on! This time on the GameBoy Color. OutRun GB is a port of the original Arcade version of Out Run to the Game Boy Color. It's the whole game - all the tracks - all the music - all the wind in your hair!
Vanderbilt Football head coach Clark Lea joins Commodore Hour to discuss the win over #11 South Carolina. Plus, look ahead to this weekend vs. Georgia State. You can listen to Commodore Football on the Vanderbilt Sports Network from Learfield. Available in Nashville on 102.5 The Game and 94.9 The Fan. Always streaming on the Vanderbilt Athletics app.See Privacy Policy at https://art19.com/privacy and California Privacy Notice at https://art19.com/privacy#do-not-sell-my-info.
Our first guests for quite some time are Taylor and Amy from The Taylor and Amy show. They join us to talk about BASIC, a teeny tiny replacement for the Commodore Datasette and a chap called Christopher Drum who has recently started a blog about productivity software and has decided to start with a deep dive into Deluxe Paint on the Amiga. But that isn't all he has to offer. Find more from Taylor and Amy thestopbits.bandcamp.com thestopbits.net https://www.youtube.com/@tayloramyshow Learn all about Casio and their technology legacy in the latest issue of Pixel Addict magazine. Reviews of brand new Home-brew games and remembering Hewson Consultants, an interview with Rob and Andrew Hewson. Loads more besides. Head over to www.addict.media 00:00 - Show Opening 02:58 - Microsoft Open-Sources a Classic! Story Link: https://github.com/microsoft/BASIC-M6502 Article 1: https://www.theregister.com/2025/09/04/microsoft_open_sources_6502_basic/ Article 2: https://www.pagetable.com/?p=46 17:13 - It's A Commodore Datasette But Is It Far Away? No It's Just Small! Story Link: https://www.tomshardware.com/pc-components/storage/remaking-a-commodore-64-datasette-from-1982-using-1993-microcassette-tech-techtuber-touts-1mb-per-tape-a-5x-improvement-over-the-original 29:06 - Housekeeping - News links found below 35:36 - Christopher Drum: Someone You Should Know Story Link: https://www.reddit.com/r/thisweekinretro/comments/1n9nncs/stone_tools_a_blog_about_retro_productivity/ Stone Tools Blog: https://stonetools.ghost.io/deluxepaint-amiga/ Channels Dave Mentioned: https://www.youtube.com/@TimberwolfK https://www.youtube.com/@Yesterzine https://www.youtube.com/@WhatHoSnorkers 50:07 - Community Question of the Week
YoutubeInstagramAmazonFacebookBioThe video for “Neon Dreamers,” the latest single from Arcade Knights, opens on a futuristic cityscape reminiscent of Blade Runner or Tron. As the visuals unfold, soaring vintage synthesizers and thunderous reverb-soaked drums create a cinematic soundscape. Digitized female vocals deliver the track's core message:We're the neon dreamers lighting up the skyChasing our tomorrow, never asking whyWith our hearts electric, breaking through the darkIn this digital world, we'll make our markEvoking the atmosphere of the Stranger Things soundtrack as much as Daft Punk, the song explores a timeless question: What does it mean to be human in a world dominated by machines?That question lies at the heart of Arcade Knights, the synthwave-cyberpunk electronic project of Canadian musician Dean Parsons. Known for his deep love of 1980s drum machines and synthesizers, Parsons incorporates authentic hardware such as the LinnDrum and Oberheim OB-8 into his work. While modern software can replicate these sounds, he prefers the analog warmth and tactile experience of physical instruments, embracing the buttons, knobs, and patch cables that bring a unique authenticity to his production process.Unlike most contemporary producers, Parsons creates entirely outside of a digital audio workstation. Every track is written, recorded, and mixed using his MPC hardware sequencer, a process he believes allows more emotion to come through the physical act of playing.“My main production machine is not a DAW,” he explains. “Every track, every note, every melody is crafted and recorded through purpose-built hardware. There's a lot of heart that comes through the keys and pads.”“Neon Dreamers” serves as a companion piece to Cyber Hack, the full-length album released earlier this year. The record tells the story of hackers raised in an AI-driven world who use their skills to protect humanity, ensuring technology serves people rather than controlling them.The theme reflects Parsons' own life. Growing up in the 1980s surrounded by Commodore 64s and science-fiction films like Terminator and RoboCop, and later working as a cybersecurity expert, he has lived at the intersection of the analog and digital worlds.“It's important to embrace technology, but not let it control your life,” Parsons says. “Technology is advancing rapidly, and if we continue to depend on it blindly, it may begin to control us. I love technology, but it's a double-edged sword. The message of Cyber Hack is that we must remain the ones in control.”Become a supporter of this podcast: https://www.spreaker.com/podcast/creator-to-creators-with-meosha-bean--4460322/support.
Grath és Stöki retro videojátékos podcastjának nem retrós vadhajtása, havi hírkommentálás. Fő téma: részletek a Commodore 64 Ultimate-ről, emellett kibeszéltünk még egy rakás augusztusi hírt. Kísérőposzt: https://iddqd.blog.hu/2025/09/11/checkpoint_now_2025_08_hozsanna_neked_c64_ultimate 00:01:03 - Ezzel játszottunk a hónapban 00:16:35 - Kommentekre reagálás 00:24:22 - A hónap témája 00:37:55 - Havi kurrens hírek 01:35:54 - Üzleti hírek 01:42:00 - Retrós hírek 01:47:18- Filmes hírek 02:02:20 - Halasztások, bejelentések májusban 02:11:42 - A hónap izéi
Lucas Lund returns with a crowdfunding campaign which aims to translate the Swedish novel based on the C64 "The Detective Game" game, into English! Learn more of the challenges and the way to go to make this awesome book accessible to the world beyond Sweden! (Does not contain spoilers!). The interview starts at minute 38:22 into the podcast.
Hej Somna. I kväll drar vi ut en lång, skimrande VHS-tråd ur minnet och fastnar i Ridgewood High – den svenska högstadieskolan som fick ett amerikanskt namn bara för att det var 1985 och allt lät bättre i neon. Vi följer Lena Louise med sin trassel-fria Walkman-sladd och Johnny Jesper med diktboken i innerfickan. Skåpen har humör, kassettbandet säger sanningen, och overheadapparaten öppnar en portal rakt in i gympasalens rökmaskinsdimma. Coach Bengtsson smygspelar panflöjt som om ingen hör (ingen gör det, nästan). Kärleken går genom ett lås med kombination 11-24-3 och vidare via en Commodore 64 som blinkar “RUN”.Du behöver inte förstå symboliken, Somna. Låt bara linoleumets gnissel, discokulans prickar och ett mycket bestämt “spola tillbaka!” skölja över dig. Det är som det är. Det som händer, händer. Och just nu finns ingenting som vi kan göra åt det. Nu börjar vi.Sov Gott!Mer om Henrik, klicka här: https://linktr.ee/HenrikstahlLyssna utan reklam, få extraavsnitt, spellistor med mera på: https://somnamedhenrik.supercast.com/ Hosted on Acast. See acast.com/privacy for more information.
Vanderbilt Football head coach Clark Lea joins Commodore Hour to recap the win over Virginia Tech and look ahead to this weekend at South Carolina. Listen to Commodores Football on the Vanderbilt Sports Network from Learfield. Available on 102.5 The Game and 94.9 The Fan in Nashville. Always streaming on the Vanderbilt Athletics app.See Privacy Policy at https://art19.com/privacy and California Privacy Notice at https://art19.com/privacy#do-not-sell-my-info.
Thunderstorms were raging across southern Germany as Elliot Williams was joined by Jenny List for this week's podcast. The deluge outside didn't stop the hacks coming though, and we've got a healthy smorgasbord for you to snack from. There's the cutest ever data cassette recorder taking a tiny Olympus dictation machine and re-engineering it with a beautiful case for the Commodore 64, a vastly overcomplex machine for perfectly cracking an egg, the best lightning talk timer Hackaday has ever seen, and a demoscene challenge that eschews a CPU. Then in Quick Hacks we've got a QWERTY slider phone, and a self-rowing canoe that comes straight out of Disney's The Sorcerer's Apprentice sequence. For a long time we've had a Field guide series covering tech in infrastructure and other public plain sight, and this week's one dealt with pivot irrigation. A new subject for Jenny who grew up on a farm in a wet country. Then both editors are for once in agreement, over using self-tapping screws to assemble 3D-printed structures. Sit back and enjoy the show!
No Agenda Episode 1796 - "Zeds" "Zeds" Executive Producers: Sir Kevin Keeper of the Spee, Secretary-General of Portland Sir Digi Jason Daniels - Secretary-General of West Texas, Commodore of Coleman County, Knight of Lake Highlands and Duke of the Republic of Texas Sir Robert, Knight of the Seven Villages, and Sir Jonny B. Good Sir Scovee Sir Gene Knight of Neurogenesis Associate Executive Producers: Sir Ara Derderian Zane Petersen Eli the coffee guy Linda Lu Duchess of jobs & writer of winning resumes Secretary-General: Sir Kevin Keeper of the Spee, Secretary-General of Portland Sir Digi Sir Jason Daniels, Secretary-General of West Texas Adam Curry, Secretary General of Podcasting. Become a member of the 1797 Club, support the show here Boost us with with Podcasting 2.0 Certified apps: Podverse - Podfriend - Breez - Sphinx - Podstation - Curiocaster - Fountain Title Changes Sir Kevin Keeper of the Spee > Baron Art By: Nessworks End of Show Mixes: The False Flags and Sir Dewcifer - Bonald Crabtree Engineering, Stream Management & Wizardry Mark van Dijk - Systems Master Ryan Bemrose - Program Director Back Office Jae Dvorak Chapters: Dreb Scott Clip Custodian: Neal Jones Clip Collectors: Steve Jones & Dave Ackerman NEW: and soon on Netflix: Animated No Agenda Sign Up for the newsletter No Agenda Peerage ShowNotes Archive of links and Assets (clips etc) 1796.noagendanotes.com Directory Archive of Shownotes (includes all audio and video assets used) archive.noagendanotes.com RSS Podcast Feed Full Summaries in PDF No Agenda Lite in opus format Last Modified 09/04/2025 17:09:50This page created with the FreedomController Last Modified 09/04/2025 17:09:50 by Freedom Controller
What does male self care mean to you? Remember, there are no right or wrong answers to this question; to Luke it means going to a football match alone. To Peter it's a dog walk and a wank. Do whatever works for you. Today on The Luke and Pete Show, Peter is dropping extortionate amounts of money in the NCP, Luke is drinking shandies and doesn't care who judges him (he definitely does), and we explore further why a man has bought the Commodore brand. Oh, and we may have to prise open the Battery Daddy again...Email us at hello@lukeandpeteshow.com or you can get in touch on X, Threads or Instagram if character-restricted messaging takes your fancy.Please fill out Stak's listener survey! It'll help us learn more about the content you love so we can bring you even more - you'll also be entered into a competition to win one of five PlayStation 5's! Click here: https://bit.ly/staksurvey2025 Hosted on Acast. See acast.com/privacy for more information.
Head coach Clark Lea talks about the win over Charleston Southern and looks ahead to this weekend against Virginia Tech. Listen to the Commodores and Hokies on the Vanderbilt Sports Network from Learfield. Available on 102.5 The Game in Nashville. Always streaming on the Vanderbilt Athletics app.See Privacy Policy at https://art19.com/privacy and California Privacy Notice at https://art19.com/privacy#do-not-sell-my-info.
This show has been flagged as Clean by the host. Hello, I'm Wojciech (pronounciation available at https://en.wiktionary.org/wiki/Wojciech ), I'm a nerd from Poland, I work as a software engineer. I've found HPR about a year ago and wanted to record a show since. But life is busy. I'm trying it out, in a supermarket parking lot in my car. This is my second attempt, so we'll see how it works. How I got into tech? In a way I've kind of always been there. At least since I was a child. The story that I like to tell is when I was about 4 years old my cousing launched me Mortal Kombat on his Amiga computer and I got interested. That's my oldest tech related memory. As a kid I've mostly played video games. Mostly on clones of old 8-bit consoles like Atari 2600 or NES, later some unspecified models of Commodore and Schneider computers. I don't even remember what exact models they were. Got my first PC at about 10 years old, it was an Intel 486SX, 12 MB RAM, 850 MB HDD, running Windows 95. Still mostly playing games on the computer but, as it was running Windows, as you maybe know, with Windows come problems. Sometimes user-induced, but not always. Spoiler, it's been over 25 years and this trend continues. Around the same time my sister went to high school and got a Turbo Pascal textbook. This is what really got me interested in programming and that's when my interests and career in software development begun. Since that time I had a very good idea what I want to do in life. I just knew I wanted to work with computers, primarily doing software engineering. I went to a technical university, Wrocław University of Science and Technology. And there I got interested in other computer related things like networking and I also got into digital and analog electronics. Just because I really wanted to go that one level deeper, to learn about how computers work, and electronics in general. I also have other interests, but tech and non-tech related, like for example science fiction literature and I would like to record some shows about those in the future. We shall see. There is one specific story I want to tell, but I think I will save it for October. Why October? Because it is a workplace horror story about... Windows. Well, not really a horror story story, but it was really bizarre and can be described as such. In the meantime I don't want to promise anything. But maybe I will record a show about what I am currently doing at work, which is the topic of audit trail in software applications. But I am chaotic and may do something entirely different. We shall see. I think that's all I want to say today. I would really appreciate if you left some feedback. Was the audio OK, is my English enough, did I speak too fast? English is not my first language and I've noticed over the years that I really tend to speak too fast when using English. And that's it, thank you for listening. Hopefully we'll hear in the future from me. Provide feedback on this episode.
ARG Presents is BACK this week for an fun discussion on Ports of games that are BETTER then the originals! Join Amigo Aaron and THE BRENT for some laughs as we discuss games that fit the bill, and then submit our own as we tackle Bionic Commando on the Nintendo NES and Slap Fight MD on the original Sega Megadrive / Genesis!
Bienvenue dans le deux-cent-quatre-vingt-quinzième épisode de CacaoCast! Dans cet épisode, Philippe Casgrain et Philippe Guitard discutent des sujets suivants: Apple Event “Awe Dropping” - Les nouveautés de l'automne AFP - Maintenant obsolète avec macOS Sequoia 15.5 Swift concurrency - La documentation mise-à-jour GitDesktop - Un client Git simplifié VoltStar - Le chargement de votre Polestar dans la barre de menus SillyBalls - Un classique Mac QuickDraw réinventé Commodore - Le retour du C64 AltWeatherCan - Si vous vous ennuyez de l'application météo d'Environnement Canada Ecoutez cet épisode
Mastering Product Launches: Fanfare's Secret to Successful Drops Fanfare.io About the Guest(s): Michael Dodsworth is the founder and CEO of Fanfare, a company that aims to revolutionize high-stakes product launches and consumer experiences. With over two decades of experience helping brands and artists navigate events and product launches, Michael has a rich history in managing online and live event platforms. He previously worked with companies that have tackled issues like server crashes and bot activities. Michael's goal with Fanfare is to deliver fairness and transparency to fans while offering powerful tools to brands to convert hype into lasting loyalty. Episode Summary: In this engaging episode of The Chris Voss Show, host Chris Voss sits down with Michael Dodsworth, the founder and CEO of Fanfare, to discuss the complexities of high-stakes product launches and how they can be managed more efficiently. The episode is packed with insights into the world of consumer experiences, the pitfalls companies face in the digital and live event spaces, and innovative solutions offered by Fanfare to overcome these challenges. Michael shares his journey from an engineer intrigued by scale issues to an entrepreneur on a mission to transform product launches. He explains how Fanfare's front-end solutions help brands protect against server meltdowns and bot attacks during launches, creating a seamless experience for both the company and the consumer. The discussion delves into the importance of creating VIP experiences for fans and customers to foster brand loyalty, using data-driven strategies to ensure that loyal consumers feel valued beyond mere purchase history. The episode is a must-listen for anyone interested in event management, marketing, or consumer psychology. Key Takeaways: Fanfare provides innovative solutions for brands to improve the consumer experience during high-stakes product launches and events, preventing server crashes and bot issues. Building a consumer-friendly launch experience can significantly increase customer loyalty and conversions, transforming hype into sustainable brand engagement. The importance of creating exclusive, VIP experiences for your most engaged consumers can far outweigh traditional discount-driven strategies. Legacy brands can learn from the innovative strategies employed by sneaker culture and brands like Supreme, where scarcity and exclusivity drive consumer demand. Michael Dodsworth's journey from a Commodore 64 enthusiast to a powerhouse CEO highlights the role of passion and engineered solutions in solving complex market challenges. Notable Quotes: "We sit in front of whatever vendor you're using, and we'll facilitate that experience." "Fostering loyalty and fostering fandom is something we've started to see spill out into different categories." "What drives fandom with folks is not things like discount codes, it's exclusivity." "It's a really powerful model if you can achieve it." "We've seen brands go through this pain, and we wanted to capture that information."
In this episode of The Retail Perch, Shekar Raman and Gary Hawkins are joined by Virginia Marsh, Head of Data, Agency & Platforms at Fluent Inc. Virginia's career began loading trucks in Puerto Rico and took a pivotal turn when she taught herself to code on a Commodore computer. That early curiosity grew into a passion for data that now shapes how she helps retailers make smarter decisions. She shares her perspective on when data is relevant and when it is not, offering practical insights on how retailers can cut through the noise and stay competitive in a changing industry.
We're back for Episode 161!In this episode the boys catch up on what they've been playing and adding to their collections + 6 Good DS Games 9:16- Quick Questions21:18 - Patreon25:52 - Eric's Take - Physical Games Backlog58:12 - Catching Up2:06:44 - 6 Good DS Games Please give us a review on Apple Podcasts!Thanks for listening!You can always reach us at podcast@pixelgaiden.com. Send us an email if we missed anything in the show notes you need. You can now support us on Patreon. Thank you to Henrik Ladefoged, Roy Fielding, Daniel James, 10MARC, Eric Sandgren, Brian Arsenault, Retro Gamer Nation, Maciej Sosnowski, Paradroyd, RAM OK ROM OK, Mitsoyama, David Vincent, Ant Stiller, Mr. Toast, Jason Holland, Mark Scott, Vicky Lamburn, Mark Richardson, Scott Partelow, Paul Jacobson, Steve Rasmussen, Steve Rasmussen's Mom, Retro Gamer Nation, Peter Price, Brett Alexander, Jason Warnes, Josh Malone (48kram), AndrewSan, Jochwat, John Shawler, and Adam from Commodore Chronicles for making this show possible through their generous donation to the show. Support our sponsor Retro Rewind for all of your Commodore needs! Use our page at https://retrorewind.ca/pixelgaiden and our discount code PG10 for 10%
We're back for Episode 161! In this episode the boys catch up on what they've been playing and adding to their collections + 6 Good DS Games 9:16- Quick Questions 21:18 - Patreon 25:52 - Eric's Take - Physical Games Backlog 58:12 - Catching Up 2:06:44 - 6 Good DS Games Please give us a review on Apple Podcasts! Thanks for listening! You can always reach us at podcast@pixelgaiden.com. Send us an email if we missed anything in the show notes you need. You can now support us on Patreon. Thank you to Henrik Ladefoged, Roy Fielding, Daniel James, 10MARC, Eric Sandgren, Brian Arsenault, Retro Gamer Nation, Maciej Sosnowski, Paradroyd, RAM OK ROM OK, Mitsoyama, David Vincent, Ant Stiller, Mr. Toast, Jason Holland, Mark Scott, Vicky Lamburn, Mark Richardson, Scott Partelow, Paul Jacobson, Steve Rasmussen, Steve Rasmussen's Mom, Retro Gamer Nation, Peter Price, Brett Alexander, Jason Warnes, Josh Malone (48kram), AndrewSan, Jochwat, John Shawler, and Adam from Commodore Chronicles for making this show possible through their generous donation to the show. Support our sponsor Retro Rewind for all of your Commodore needs! Use our page at https://retrorewind.ca/pixelgaiden and our discount code PG10 for 10%
The Vectrex mini and TheA1200 are two new pieces of gaming hardware that are on their way. We talk about the Commodore 128, did it make it onto your radar back in the day? 30 years ago Microsoft made a big splash about Windows 95 and somehow became sort of cool.... Issue 9 of SEGA MANIA covers the first half of 1996 which is when the Saturn started picking up a little bit of steam. The Mega Drive also gets plenty of coverage as even in 1996 it was still giving the world some great games. Visit www.sega-mania.com to secure your copy. 00:00 - Show Opening 04:31 - The “THEA1200” Or A Mini Vectrex? Story Link: https://vectrex.com/ As seen at Gamescom: https://www.youtube.com/watch?v=GIdKfuCwCKk Home made Vectrex: https://www.gamesradar.com/hardware/retro/after-42-years-someone-has-finally-worked-out-a-way-to-make-a-mini-version-of-my-favorite-80s-console-and-it-involves-an-amoled-screen/ TheA1200 at Gamescom: https://www.timeextension.com/news/2025/08/retro-games-ltds-full-size-amiga-replica-the-a1200-resurfaces-at-gamescom Retro Games Limited Facebook: https://www.facebook.com/THEC64andMoreByRetroGamesLtd/posts/pfbid029FCDzrNpiUHWBC7yi3tAnyScn4hZwDoYgSU53vZQmN2ecPfbzLta9ysex8HjF6oAl?rdid=8CqcWT0xHwpFGv46 Amigang coverage: https://amigang.com/the-a1200/ 21:31 - Bad News For IBM & Apple! The Commodore 128 Revisited Story Link: https://www.heise.de/en/news/40-years-of-the-C128-Commodore-s-last-8-bit-attempt-10229308.html Additional Link: https://www.tomshardware.com/desktops/ces-2025-is-the-40th-anniversary-of-the-commodore-128-the-last-8-bit-pc-first-appeared-at-ces-1985 39:02 - Housekeeping - News links found below 45:29 - Never Mind Your Commodore The Real Deal Is 30 Years Old - Windows 95! Story Link: https://www.techradar.com/computing/windows/i-was-at-the-windows-95-launch-30-years-ago-i-still-cant-stop-thinking-about-it 55:50 - Community Question of the Week
Goutham Rao grew up in Brooklyn, a nerd all his life. Back in the day, his Dad bought him a Commodore 64, from which he started to learn to write code in BASIC. Eventually, he attended the University of Pennsylvania to get his Masters in Computer Science. Outside of tech, he is married with 2 kids. He likes to travel, and likes to run. He used to compete in half marathons, but nowadays, he does his running as more of a mental exercise.Goutham saw that IT telemetry logs have a lot of complexity within their data. Fast forward to today, he and his co-founders noticed the way that LLMs were processing data. They thought they could build something to interpret this data, and "clone" themselves to create something that mimics issue triage.This is the creation story of Neubird.SponsorsPaddle.comSema SoftwarePropelAuthPostmanMeilisearchMailtrap.TECH Domains (https://get.tech/codestory)Linkshttps://neubird.ai/https://www.linkedin.com/in/gouthamrao/Support this podcast at — https://redcircle.com/code-story-insights-from-startup-tech-leaders/donationsAdvertising Inquiries: https://redcircle.com/brandsPrivacy & Opt-Out: https://redcircle.com/privacy
© 2020-2025 Ivy Podcast Discovery LLC
