Whatsit.today is a new word guessing game where players try to decipher a hidden five-letter word by submitting guesses. Feedback is provided after each guess, revealing which letters are correct and if they are in the correct position within the word. The game offers a daily puzzle and the opportunity for unlimited practice. The creator is seeking feedback on their project.
This project showcases a JavaScript-based Chip-8 emulator. The emulator is implemented entirely in JavaScript, allowing it to run directly in a web browser. It aims to provide a simple and accessible way to experience classic Chip-8 games. The project is hosted on GitHub and includes the emulator's source code, making it easy for others to explore, learn from, and contribute to the project.
Hacker News users discussed the JavaScript Chip-8 emulator, primarily focusing on its educational value for learning emulator development. Several commenters shared their own positive experiences with Chip-8 as a starting point, praising its simplicity and well-defined specifications. Some discussed specific implementation details like handling timers and quirky ROM behavior. Others suggested potential improvements or additions, such as adding debugging features or exploring different rendering approaches like using canvas or WebGL. One commenter highlighted the emulator's usefulness for testing and debugging ROMs, while another appreciated the clean code and ease of understanding. Overall, the comments reflected a positive reception to the project, emphasizing its educational merit and potential as a foundation for more complex emulator projects.
Koto is a modern, general-purpose programming language designed for ease of use and performance. It features a dynamically typed system with optional type hints, garbage collection, and built-in support for concurrency through asynchronous functions and channels. Koto emphasizes functional programming paradigms but also allows for imperative and object-oriented styles. Its syntax is concise and readable, drawing inspiration from languages like Python and Lua. Koto aims to be embeddable, with a small runtime and the ability to compile to bytecode or native machine code. It is actively developed and open-source, promoting community involvement and contributions.
Hacker News users discussed Koto's design choices, praising its speed, built-in concurrency support based on fibers, and error handling through optional values. Some compared it favorably to Lua, highlighting Koto's more modern approach. The creator of Koto engaged with commenters, clarifying details about the language's garbage collection, string interning, and future development plans, including potential WebAssembly support. Concerns were raised about its small community size and the practicality of using a niche language, while others expressed excitement about its potential as a scripting language or for game development. The discussion also touched on Koto's syntax and its borrow checker, with commenters offering suggestions and feedback.
Jussi Koskela, the creator of Deluxe Ski Jump, discusses the game's origins, development, and enduring popularity in this interview. Starting as a simple project inspired by a Finnish ski jumping game, Koskela iteratively improved the physics and gameplay based on player feedback, leading to its widespread success, especially in Finland. He highlights the importance of community involvement and the dedicated modding scene that has extended the game's lifespan. Despite not actively developing the game anymore, Koskela expresses gratitude for its impact and the continued passion of its players.
Hacker News users discuss the simplicity and longevity of Deluxe Ski Jump, praising its addictive gameplay and minimal system requirements. Several commenters reminisce about playing the game in their youth, highlighting the nostalgic appeal. The discussion also touches on the game's development, including its origins as a QBasic project and the creator's surprise at its enduring popularity. Some users express interest in the game's physics engine and its realistic, albeit simplified, representation of ski jumping. The overall sentiment is one of appreciation for a classic game that continues to entertain despite its age.
EmptyEpsilon is a free and open-source spaceship bridge simulator designed for collaborative gameplay. It features a minimalist, vector-based aesthetic and focuses on providing a framework for users to create their own custom ships, roles, and gameplay mechanics. The simulator uses a client-server architecture, allowing multiple players to connect and operate different stations on the bridge. While it comes with a basic starter ship and some pre-built functionality, EmptyEpsilon is primarily intended as a platform for users to build upon and tailor to their own specific needs and preferences, using HTML, CSS, and JavaScript.
Several commenters on Hacker News expressed excitement about EmptyEpsilon, praising its impressive visuals and potential for collaborative gameplay. Some drew comparisons to Artemis Spaceship Bridge Simulator, noting EmptyEpsilon's more modern graphics and user interface. A few users discussed the challenges of running such a simulator smoothly, particularly with larger groups, and questioned the choice of Godot as the engine. There was also interest in the project's open-source nature, with suggestions for potential features and improvements, like adding more realistic ship systems and expanding the scripting capabilities. A recurring theme was the desire for more complex gameplay mechanics beyond simple button-pressing, emphasizing the need for strategic depth to maintain long-term engagement.
This blog post details the author's process of creating a Checkers game using Rust and compiling it to WebAssembly (WASM) for play in a web browser. The author highlights the benefits of using Rust, such as performance and memory safety, and the relative ease of targeting WASM. They describe key implementation aspects, including game logic, board representation, and user interface interaction using the Yew framework. The post also covers setting up the Rust and WASM build environment, and optimizing the WASM module size for faster loading. The final result is a playable checkers game embedded directly in the webpage, demonstrating the practicality of Rust and WASM for web development.
HN commenters generally praised the clean and performant implementation of Checkers in Rust and WASM. Several lauded the clear code and the educational value of the project, finding it a good example of Rust and WASM usage. Some discussed performance considerations, including the choice of using a 1D array for the board representation, suggesting a 2D array might offer better readability despite potentially slightly reduced performance. A few comments touched on potential enhancements, like adding an AI opponent or allowing undo/redo functionality. There was also minor discussion around alternative approaches to game development with Rust/WASM and other languages.
Bubbles is a simple, yet addictive web game built entirely with vanilla JavaScript, requiring no external libraries or frameworks. The goal is to click and pop rising bubbles before they reach the top of the screen. Each popped bubble awards points based on its size, with smaller bubbles giving more points. The game features increasing difficulty as the bubbles rise faster over time. It's a lightweight, browser-based experience designed for quick bursts of fun.
Hacker News users generally praised the game's simplicity and clean implementation, using vanilla JavaScript without frameworks. Several commenters appreciated the satisfying gameplay and the nostalgic feel, reminiscent of early web games. Some suggested potential improvements, like adding sound effects, different bubble sizes, or a score counter. A few users delved into technical aspects, discussing the collision detection algorithm and potential performance optimizations. One commenter even shared a modified version with added features. The overall sentiment was positive, with many finding the game a fun and well-executed example of simple web development.
This Scratch project presents a simple city simulator where users can build roads, houses, and power lines to create a functional city. Resources like power and population are tracked, and the city's growth is influenced by the player's infrastructure decisions. The goal is to develop a thriving metropolis by strategically placing buildings and ensuring adequate power distribution. The simulator features a top-down view, a grid-based building system, and visual indicators of resource levels.
HN users generally praised the Scratch city simulator for its impressive functionality given the platform's limitations. Several noted the clever use of lists and variables to manage the simulation's complexity. Some suggested potential improvements like adding zoning, traffic simulation, and different building types. One commenter highlighted the educational value of such projects, encouraging exploration of underlying concepts like cellular automata. Others reminisced about their own early programming experiences and the accessibility that Scratch provides. A few users expressed skepticism about the project's scalability and performance, but the overall sentiment was positive, appreciating the creator's ingenuity.
The "Steam Networks" post explores the idea of building generative AI models that can be interconnected and specialized, like a network of steam engines powering a factory. Instead of relying on one massive, general-purpose model, this approach proposes creating smaller, more efficient models, each dedicated to a specific task or domain. These "steam engines" would then be linked together, passing data and intermediate representations between each other to solve complex problems. This modular design offers several potential advantages: improved efficiency, easier customization and updating, enhanced robustness, and the ability to leverage specialized hardware. The post argues that this network approach is a more scalable and sustainable path forward for AI development compared to the current focus on ever-larger monolithic models.
Hacker News users discussed the potential for Steam to leverage its massive user base and existing infrastructure to create a social network exceeding the scale of platforms like Facebook or Twitter. Some expressed skepticism, citing Valve's history of abandoning projects and the difficulty of moderating a network of that size, especially given the gaming community's potential for toxicity. Others pointed to the success of Discord and suggested Steam could integrate similar features or acquire an existing platform. The potential for targeted advertising within a gaming-focused social network was also highlighted, along with concerns about privacy and data collection. Several commenters emphasized the importance of Steam remaining focused on its core competency of game distribution and avoiding feature creep. The idea of incorporating elements of fandom and community building tools was also discussed, along with the challenges of incentivizing user participation and content creation. The overall sentiment seemed to be a cautious curiosity, acknowledging the potential while recognizing the substantial hurdles involved.
Lego is transitioning towards developing its video games internally. After the closure of TT Games' exclusivity deal, Lego is building internal development capabilities to supplement and potentially replace external studios in the future. While they will continue partnerships with existing studios like Sumo Digital for upcoming titles, Lego aims to gain more creative control and a faster development cycle by bringing expertise in-house. This shift reflects a broader strategy to own more of the Lego gaming experience.
Hacker News users discuss the potential ramifications of Lego bringing game development in-house. Some express skepticism, questioning if Lego possesses the necessary expertise to manage large-scale game development and suggesting it could lead to less creative and more "on-brand" titles. Others are more optimistic, hoping for a return to the charm of older Lego games and speculating that internal development could allow for tighter integration with physical Lego sets and the broader Lego ecosystem. A recurring theme is concern about the potential loss of TT Games' unique touch and the possibility of Lego repeating mistakes made by other companies that brought development in-house. Several commenters also highlight the challenges of managing large development teams and maintaining consistent quality.
Reverse engineering of Shenmue's source code revealed that the sun's position in the game is calculated using a simplified formula that doesn't account for axial tilt or the equation of time. This results in the sun rising and setting slightly earlier than it should in the game's real-world counterpart of Yokosuka, Japan, across all in-game dates. While noticeable, this discrepancy doesn't significantly impact gameplay and may have been a deliberate simplification for performance reasons on the Dreamcast. The author speculates whether it qualifies as a "bug" given its likely intentional nature and minimal effect on the overall experience.
Hacker News users discuss whether the perceived sun position error in Shenmue is actually a bug or a deliberate design choice. Some commenters suggest it's a performance optimization, avoiding complex calculations for marginally improved visuals. Others argue it's simply a bug, pointing to inconsistencies with the in-game clock and world design. Several discuss the challenges of reverse engineering older games, particularly with limited documentation, and the difficulty of definitively labeling something a bug without access to the original source code and developer intentions. The discussion also touches on the nostalgic appeal of Shenmue and the dedication of its fan community in dissecting the game's intricacies.
AudioNimbus is a Rust implementation of Steam Audio, Valve's high-quality spatial audio SDK, offering a performant and easy-to-integrate solution for immersive 3D sound in games and other applications. It leverages Rust's safety and speed while providing bindings for various platforms and audio engines, including Unity and C/C++. This open-source project aims to make advanced spatial audio features like HRTF-based binaural rendering, sound occlusion, and reverberation more accessible to developers.
HN users generally praised AudioNimbus for its Rust implementation of Steam Audio, citing potential performance benefits and improved safety. Several expressed excitement about the prospect of easily integrating high-quality spatial audio into their projects, particularly for games. Some questioned the licensing implications compared to the original Steam Audio, and others raised concerns about potential performance bottlenecks and the current state of documentation. A few users also suggested integrating with other game engines like Bevy. The project's author actively engaged with commenters, addressing questions about licensing and future development plans.
VSC is an open-source 3D rendering engine written in C++. It aims to be a versatile, lightweight, and easy-to-use solution for various rendering needs. The project is hosted on GitHub and features a physically based renderer (PBR) supporting features like screen-space reflections, screen-space ambient occlusion, and global illumination using a path tracer. It leverages Vulkan for cross-platform graphics processing and supports integration with the Dear ImGui library for UI development. The engine's design prioritizes modularity and extensibility, encouraging contributions and customization.
Hacker News users discuss the open-source 3D rendering engine, VSC, with a mix of curiosity and skepticism. Some question the project's purpose and target audience, wondering if it aims to be a game engine or something else. Others point to a lack of documentation and unclear licensing, making it difficult to evaluate the project's potential. Several commenters express concern about the engine's performance and architecture, particularly its use of single-threaded rendering and a seemingly unconventional approach to scene management. Despite these reservations, some find the project interesting, praising the clean code and expressing interest in seeing further development, particularly with improved documentation and benchmarking. The overall sentiment leans towards cautious interest with a desire for more information to properly assess VSC's capabilities and goals.
Playscl is a platform for creating and playing simple, editable games. Users can modify existing games or build their own from scratch using a visual, block-based scripting language. The focus is on accessibility and ease of use, encouraging experimentation and sharing within the community. The platform aims to empower users to not just play games, but to understand and modify the mechanics behind them, fostering creativity and learning through playful exploration.
HN commenters were generally positive about the "editable games" concept presented. Several praised the simplicity and educational potential, suggesting it could be a great tool for teaching programming concepts or creating quick prototypes. Some expressed interest in seeing more complex examples and features like multiplayer functionality. A few commenters drew parallels to existing platforms like Bitsy and Pico-8, highlighting the niche this project fills for accessible game creation. Some questioned the long-term viability and whether the "edit while playing" aspect was truly novel, but the overall reception leaned towards appreciation for its ease of use and potential as a learning tool or creative outlet. A couple of users pointed out missing features such as undo/redo and improved UI elements.
This project introduces lin-alg, a Rust library providing fundamental linear algebra structures and operations with a focus on performance. It offers core types like vectors and quaternions (with 2D, 3D, and 4D variants), alongside common operations such as addition, subtraction, scalar multiplication, dot and cross products, normalization, and quaternion-specific functionalities like rotations and spherical linear interpolation (slerp). The library aims to be simple, efficient, and dependency-free, suitable for graphics, game development, and other domains requiring linear algebra computations.
Hacker News users generally praised the Rust vector and quaternion library for its clear documentation, beginner-friendly approach, and focus on 2D and 3D graphics. Some questioned the practical application of quaternions in 2D, while others appreciated the inclusion for completeness and potential future use. The discussion touched on SIMD support (or lack thereof), with some users highlighting its importance for performance in graphical applications. There were also suggestions for additional features like dual quaternions and geometric algebra support, reflecting a desire for expanded functionality. Some compared the library favorably to existing solutions like glam and nalgebra, praising its simplicity and ease of understanding, particularly for learning purposes.
Spark Texture Compression 1.2 introduces significant performance enhancements, particularly for mobile GPUs. The update features improved ETC1S encoding speed by up to 4x, along with a new, faster ASTC encoder optimized for ARM CPUs. Other additions include improved Basis Universal support, allowing for supercompression using both UASTC and ETC1S, and experimental support for generating KTX2 files. These improvements aim to reduce texture processing time and improve overall performance, especially beneficial for mobile game developers.
Several commenters on Hacker News expressed excitement about the improvements in Spark 1.2, particularly the smaller texture sizes and faster loading times. Some discussed the cleverness of the ETC1S encoding method and its potential benefits for mobile game development. One commenter, familiar with the author's previous work, praised the consistent quality of their compression tools. Others questioned the licensing terms, specifically regarding commercial use and potential costs associated with incorporating the technology into their projects. A few users requested more technical details about the compression algorithm and how it compares to other texture compression formats like ASTC and Basis Universal. Finally, there was a brief discussion comparing Spark to other texture compression tools and the different use cases each excels in.
FastDoom achieves its speed primarily through optimizing data access patterns. The original Doom wastes cycles retrieving small pieces of data scattered throughout memory. FastDoom restructures data, grouping related elements together (like vertices for a single wall) for contiguous access. This significantly reduces cache misses, allowing the CPU to fetch the necessary information much faster. Further optimizations include precalculating commonly used values, eliminating redundant calculations, and streamlining inner loops, ultimately leading to a dramatic performance boost even on modern hardware.
The Hacker News comments discuss various technical aspects contributing to FastDoom's speed. Several users point to the simplicity of the original Doom rendering engine and its reliance on fixed-point arithmetic as key factors. Some highlight the minimal processing demands placed on the original hardware, comparing it favorably to the more complex graphics pipelines of modern games. Others delve into specific optimizations like precalculated lookup tables for trigonometry and the use of binary space partitioning (BSP) for efficient rendering. The small size of the game's assets and levels are also noted as contributing to its quick loading times and performance. One commenter mentions that Carmack's careful attention to performance, combined with his deep understanding of the hardware, resulted in a game that pushed the limits of what was possible at the time. Another user expresses appreciation for the clean and understandable nature of the original source code, making it a great learning resource for aspiring game developers.
This post provides a practical guide to using Perlin noise for creating realistic terrain features in procedural generation. It covers fundamental concepts like octaves and persistence, explaining how combining different noise scales creates complex landscapes. The guide then demonstrates how to apply Perlin noise to generate mountains by treating noise values as elevation, cliffs by using thresholds to create sharp drops, and cave systems by applying 3D Perlin noise and manipulating thresholds to carve out intricate networks. It also touches on optimizing performance and integrating these techniques into game development workflows. The overall goal is to equip developers with the knowledge and techniques to generate compelling and varied landscapes using Perlin noise.
HN users largely praised the article for its clear explanations and helpful visualizations of Perlin noise for procedural generation. Several commenters shared their own experiences and experiments with Perlin noise, discussing techniques like combining multiple octaves of noise for more detailed terrain, and using it for generating things beyond landscapes, like clouds or textures. Some pointed out the computational cost of Perlin noise and suggested alternatives like Simplex noise. A few users also offered additional resources and tools for working with procedural generation. One commenter highlighted the article's effective use of interactive diagrams, making it easier to grasp the concepts.
This post introduces rotors as a practical alternative to quaternions and matrices for 3D rotations. It explains that rotors, like quaternions, represent rotations as a single action around an arbitrary axis, but offer a simpler, more intuitive geometric interpretation based on the concept of "geometric algebra." The author argues that rotors are easier to understand and implement, visually demonstrating their geometric meaning and providing clear code examples in Python. The post covers basic rotor operations like creating rotations from an axis and angle, composing rotations, and applying rotations to vectors, highlighting rotors' computational efficiency and stability.
Hacker News users discussed the practicality and intuitiveness of using rotors for 3D rotations. Some found the rotor approach more elegant and easier to grasp than quaternions, especially appreciating the clear geometric interpretation and connection to bivectors. Others questioned the claimed advantages, arguing that quaternions remain the superior choice for performance and established library support. The potential benefits of rotors in areas like interpolation and avoiding gimbal lock were acknowledged, but some commenters felt the article didn't fully demonstrate these advantages convincingly. A few requested more comparative benchmarks or examples showcasing rotors' practical superiority in specific scenarios. The lack of widespread adoption and existing tooling for rotors was also raised as a barrier to entry.
The author, frustrated by the steep learning curve of Git, is developing a game called "Oh My Git!" to make learning the version control system more accessible and engaging. The game visually represents Git's inner workings, allowing players to experiment with commands and observe their effects on a simulated repository. The goal is to provide a safe, interactive environment for understanding core concepts like branching, merging, rebasing, and resolving conflicts, ultimately demystifying Git and reducing the frustration commonly associated with learning it. The game aims to be suitable for beginners while also offering challenges for more experienced users looking to refine their skills.
Hacker News users generally expressed enthusiasm for the Git game concept, viewing it as a valuable tool for learning a complex system. Several commenters shared their own struggles with Git and suggested specific game mechanics, such as branching and merging scenarios, rebasing challenges, and visualizing the commit graph. Some questioned the chosen game engine (Godot) and proposed alternatives like Unity or a web-based approach. There was also discussion about the potential target audience, with suggestions to focus on beginners while providing sufficient depth to engage experienced users as well. A few users highlighted existing Git learning resources, including "Oh My Git!" and the official Git documentation's interactive tutorial.
Unleashed Recompiled is a project aiming to create a native PC port of the Xbox 360 version of Sonic Unleashed, considered by many to be the superior version. It uses reverse-engineering and recompilation techniques to achieve this, rather than emulation. This allows for potential enhancements like higher resolutions, improved performance, and mod support not possible with the existing PC port based on the inferior Wii/PS2 version. The project is still in development, but playable builds are available, showcasing progress in recreating the game's functionality and visuals.
Hacker News users discuss the technical challenges and achievements of porting Sonic Unleashed to PC. Several commenters express excitement for the project, particularly its potential to improve the game's performance and visuals beyond the original Xbox 360 version. Some raise concerns about the legal implications of using extracted assets and the potential for a DMCA takedown. Others delve into the technical details of the porting process, discussing the challenges of reverse engineering and recompiling the game's code. One user suggests using a licensed version of the Hedgehog Engine 2 for a hypothetical remake, while another speculates on the game's performance on the Steam Deck. There's also discussion comparing this port to the original PC version of Sonic Generations, with some users expressing hope for similar improvements in performance and stability.
Flash games were a pivotal force in the evolution of the video game industry. Accessible through web browsers with minimal hardware requirements, Flash enabled a surge in indie game development, fostering experimentation and innovation in genres, gameplay mechanics, and monetization strategies. Many prominent developers and studios honed their skills creating Flash games, leading to the rise of indie studios and influencing later mainstream titles. The platform democratized game creation, enabling anyone with a computer and creativity to share their work with a global audience, shaping the landscape of modern gaming by paving the way for web-based gaming, mobile gaming, and the independent game development scene we know today.
HN users largely praised the article for its thoroughness and nostalgic value, recalling their own experiences with Flash games and the impact they had on their childhoods or careers. Several commenters highlighted specific games and developers that resonated with them, showcasing the breadth and influence of the Flash gaming era. Some discussed Flash's accessibility as a development platform, enabling a generation of amateur game creators. Others lamented the loss of these games due to Flash's demise and the challenges of preservation, with a few mentioning BlueMaxima's Flashpoint project as a valuable preservation effort. The technical limitations of Flash, which fostered creativity, were also a topic of conversation.
Porting an OpenGL game to WebAssembly using Emscripten, while theoretically straightforward, presented several unexpected challenges. The author encountered issues with texture formats, particularly compressed textures like DXT, necessitating conversion to browser-compatible formats. Shader code required adjustments due to WebGL's stricter validation and lack of certain extensions. Performance bottlenecks emerged from excessive JavaScript calls and inefficient data transfer between JavaScript and WASM. The author ultimately achieved acceptable performance by minimizing JavaScript interaction, utilizing efficient memory management techniques like shared array buffers, and employing WebGL-specific optimizations. Key takeaways include thoroughly testing across browsers, understanding WebGL's limitations compared to OpenGL, and prioritizing efficient data handling between JavaScript and WASM.
Commenters on Hacker News largely praised the author's clear writing and the helpfulness of the article for those considering similar WebGL/WebAssembly projects. Several pointed out the challenges inherent in porting OpenGL code, especially around shader precision differences and the complexities of memory management between JavaScript and C++. One commenter highlighted the benefit of using Emscripten's WebGL bindings for easier texture handling. Others discussed the performance implications of various approaches, including using WebGPU instead of WebGL, and the potential advantages of libraries like glium for abstracting away some of the lower-level details. A few users also shared their own experiences with similar porting projects, offering additional tips and insights. Overall, the comments section provides a valuable supplement to the article, reinforcing its key points and expanding on the practical considerations for OpenGL to WebAssembly porting.
Electronic Arts has open-sourced the source code for Command & Conquer: Red Alert, along with its expansion Tiberian Dawn, on GitHub. This release includes the original game's source code for both the DOS and Windows 95 versions, allowing modders and community developers to explore, modify, and enhance the classic RTS title. While the game data itself remains proprietary and requires ownership of the original game, this open-sourcing facilitates easier creation and compatibility of mods, potentially leading to enhanced versions, bug fixes, and new content for the classic games.
HN commenters largely expressed excitement about EA open-sourcing the Red Alert source code, anticipating the possibility of community-driven bug fixes, mods, and engine updates. Some expressed skepticism about the quality and completeness of the released code, pointing to potential issues with missing assets and the use of a pre-remaster version. Others discussed the historical significance of the release and reminisced about their experiences playing the game. Several commenters also delved into the technical details, analyzing the code structure and discussing potential improvements and porting opportunities. A few expressed disappointment that Tiberian Sun wasn't included in the release, while others hoped this open-sourcing would pave the way for future community-driven projects for other classic C&C titles.
This post explores the complexities of representing 3D rotations, contrasting quaternions with other methods like rotation matrices and Euler angles. It highlights the issues of gimbal lock and interpolation difficulties inherent in Euler angles, and the computational cost of rotation matrices. Quaternions, while less intuitive, offer a more elegant and efficient solution. The post breaks down the math behind quaternions, explaining how they represent rotations as points on a 4D hypersphere, and demonstrates their advantages for smooth interpolation and avoiding gimbal lock. It emphasizes the practical benefits of quaternions in computer graphics and other applications requiring 3D manipulation.
HN users generally praised the article for its clear explanation of quaternions and their application to 3D rotations. Several commenters appreciated the visual approach and interactive demos, finding them helpful for understanding the concepts. Some discussed alternative representations like rotation matrices and axis-angle, comparing their strengths and weaknesses to quaternions. A few users pointed out the connection to complex numbers and offered additional resources for further exploration. One commenter mentioned the practical uses of quaternions in game development and other fields. Overall, the discussion highlighted the importance of quaternions as a tool for representing and manipulating rotations in 3D space.
This YouTube video demonstrates running a playable version of DOOM within a TypeScript type definition. By cleverly exploiting the TypeScript compiler's type system, particularly recursive types and conditional type inference, the creator encodes the game's logic and data, including map layout, enemy behavior, and rendering. The "game" runs entirely within the type checker, with output rendered as a string that visually represents the game state. This showcases the surprising computational power and complexity achievable within TypeScript's type system, though it's obviously not a practical way to develop games. Instead, it serves as a fascinating exploration of the boundaries of what can be accomplished with type-level programming.
HN users were generally impressed with the technical feat of running DOOM in a TypeScript type. Several pointed out the absurdity and impracticality of the project, with one user calling it "peak type abuse." Discussion touched on the Turing completeness of TypeScript's type system, its potential misuse, and the implications for performance. Some wondered about practical applications, while others simply appreciated it as a clever demonstration of the language's capabilities. A few users questioned the definition of "running" in this context, arguing that it was more of a simulation than actual execution. There was some debate about the video's explanation clarity and a call for a blog post with a more thorough breakdown.
The original poster is seeking resources that have proven helpful for others in their game development journeys. They are specifically interested in recommendations beyond the typical beginner tutorials, hoping to find resources that have helped people move from intermediate to advanced skill levels. They're open to any type of resource, including books, courses, articles, communities, or tools, and are particularly interested in areas like game design, shaders/graphics programming, and AI.
The Hacker News comments on this "Ask HN" post offer a variety of resources for aspiring game developers. Several commenters emphasized the importance of starting small and finishing projects, recommending simple game jams and focusing on core mechanics before adding complexity. Specific resources mentioned include "Game Programming Patterns" by Robert Nystrom, Handmade Hero, and the Unity and Godot engines. A few suggested learning through decompilation or recreating classic games. Several cautioned against getting bogged down in engine choice or overly ambitious projects. The consensus seemed to be that practical experience, combined with targeted learning of core concepts, is the most effective path.
OpenJKDF2 is a cross-platform, open-source reimplementation of the Jedi Knight II: Jedi Outcast and Jedi Academy game engine written in C. It aims to be a clean and modern engine while maintaining compatibility with the original games' content, supporting both single-player and multiplayer modes. The project prioritizes features like improved rendering, physics, and networking, allowing for modifications and enhancements beyond what was possible with the original engine. It's designed to be portable and has been tested on Windows, macOS, and Linux.
Hacker News users discuss OpenJKDF2's potential benefits, including cross-platform compatibility and potential performance improvements over the original Jedi Knight II: Jedi Outcast game engine. Some express excitement about potential modding opportunities and the project's clean codebase, making it easier to understand and contribute to. Others question the practical benefits, wondering if the performance gains are substantial enough to warrant a full reimplementation. The use of CMake is praised, while concerns are raised about the licensing implications of incorporating assets from the original game. One commenter points out potential issues with online multiplayer due to timing differences, which are hard to replicate perfectly.
The Minecraft: Legacy Console Edition (LCE), encompassing Xbox 360, PS3, Wii U, and PS Vita versions, has been largely decompiled into human-readable C# code. This project, utilizing a modified version of the UWP disassembler Il2CppInspector, has successfully reconstructed much of the game's functionality, including rendering, world generation, and gameplay logic. While incomplete and not intended for redistribution as a playable game, the decompilation provides valuable insights into the inner workings of these older Minecraft versions and opens up possibilities for modding and preservation efforts.
HN commenters discuss the impressive nature of decompiling a closed-source game like Minecraft: Legacy Console Edition, highlighting the technical skill involved in reversing the obfuscated code. Some express excitement about potential modding opportunities this opens up, like bug fixes, performance enhancements, and restored content. Others raise ethical considerations about the legality and potential misuse of decompiled code, particularly concerning copyright infringement and the creation of unauthorized servers. A few commenters also delve into the technical details of the decompilation process, discussing the tools and techniques used, and speculate about the original development practices based on the decompiled code. Some debate the definition of "decompilation" versus "reimplementation" in this context.
Ren'Py is a free and open-source engine designed for creating visual novels, a genre of interactive storytelling that blends text, images, and sound. It simplifies development with a Python-based scripting language, allowing creators to easily manage dialogue, branching narratives, and character interactions. Ren'Py supports a wide range of features including animated sprites, movie playback, and various transition effects, making it accessible to both novice and experienced developers. It’s cross-platform, meaning games created with Ren'Py can be deployed on Windows, macOS, Linux, Android, iOS, and web browsers, reaching a broad audience. The engine prioritizes ease of use and provides comprehensive documentation and a supportive community, enabling creators to focus on crafting compelling stories.
Hacker News users discuss Ren'Py's ease of use, especially for non-programmers, enabling them to create visual novels with minimal coding. Several commenters praise its accessibility and the large community supporting it. Some note its limitations, especially regarding more complex game mechanics beyond the visual novel genre, though acknowledge its suitability for its intended purpose. The scripting language is described as simple yet powerful enough for narrative-focused games. A few users mention its popularity for adult visual novels, though also highlight its use in more mainstream and non-adult projects. The engine's cross-platform compatibility and active development are also seen as positive aspects.
Summary of Comments ( 216 )
https://news.ycombinator.com/item?id=43593789
HN users generally praised the simple, clean design and addictive gameplay of the word game. Several suggested improvements, such as a dark mode, a way to see definitions, and a larger word list. Some questioned the scoring system and offered alternative methods. A few pointed out similar existing games, and others offered encouragement for further development and monetization strategies. One commenter appreciated the creator's humility in presenting the game and mentioned their own mother's enjoyment of simple word games, creating a sense of camaraderie. The overall sentiment was positive and supportive.
The Hacker News post, "Show HN: I built a word game. My mom thinks it's great. What do you think?", generated several comments offering feedback and discussion.
Many commenters were supportive and encouraging of the creator, praising the game's simplicity and addictive nature. Some shared their personal experiences playing the game, noting how quickly time passed while engaged with it. A few users offered specific suggestions for improvements, like adding a timer or a competitive element with leaderboards. The "mom thinks it's great" part of the title also resonated with several commenters, who found it endearing and relatable.
Some commenters provided constructive criticism, such as addressing the mobile experience (specifically mentioning the keyboard popping up and covering the game). Others discussed the game's similarity to existing word games like Boggle and suggested ways to differentiate it further. There was also a technical discussion about the implementation details, including suggestions for using different frameworks or optimizing the code. One commenter even delved into the algorithm used for word validation, offering potential enhancements.
A recurring theme in the comments was the importance of finding the right balance between simplicity and complexity. Some users appreciated the game's minimalist design, while others suggested adding features to enhance replayability. This sparked a conversation about the target audience and the potential for appealing to different player preferences.
Overall, the comments were a mix of positive feedback, constructive criticism, and technical discussions. The creator actively engaged with the commenters, responding to questions and acknowledging the suggestions. This interaction fostered a sense of community and contributed to a productive discussion about the game's potential.