Posts in Programming
-
Flow – A Coroutine Kernel for .Net
(Christian Schladetsch)
-
C/C++ Low Level Curriculum Part 9: Loops
(Alex Darby)
-
A new way of organizing header files
(Niklas Frykholm)
-
Porting your iOS game to Blackberry Playbook (and future BB10 phones)
(Charilaos Kalogirou)
-
The Spector of Game AI
(Luke Dicken)
-
Using Chrome://tracing to view your inline profiling data
(Colt McAnlis)
-
Cleaning bad code
(Niklas Frykholm)
-
Voodoo at Origin!
(Michael A. Carr-Robb-John)
-
A simpler design for asynchronous APIs
(Niklas Frykholm)
-
Porting your game from iOS to Android
(Charilaos Kalogirou)
-
Shader Generator
(Simon Yeung)
-
Four Tips for Porting Your Game to the Web with Native Client
(Colt McAnlis)
-
More Adventures in Failing to Crash Properly
(Bruce-Dawson)
-
Unity, Replayed
(Eddie Cameron)
-
When Even Crashing Doesn’t Work
(Bruce-Dawson)
-
Matrices, Rotation, Scale and Drifting
(Niklas Frykholm)
-
The less the code, the better
(Jaewon Jung)
-
Photon Mapping Part 2
(Simon Yeung)
-
Localization Pipeline
(Michael A. Carr-Robb-John)
-
Never build upon closed-source frameworks
(Rob-Galanakis)
-
WPA–Xperf Trace Analysis Reimagined
(Bruce-Dawson)
-
Hack Day Report
(Niklas Frykholm)
-
Writing portable code: A process full of gain
(Charilaos Kalogirou)
-
Smoothsort vs. Timsort
(Jaewon Jung)
-
Photon Mapping Part 1
(Simon Yeung)
-
On Simplexity
(Christian Schladetsch)
-
The Costco-ification of Leaderboards
(David Czarnecki)
-
[Video] Why Salt is good for you: Handling password security in web applications
(Jason-Swearingen)
-
In Praise of Idleness
(Bruce-Dawson)
-
Read my lips: No more loading screens
(Niklas Frykholm)
-
The Depth Jam
(Jonathan Blow)
-
x64 ABI: Intro to the Windows x64 Calling Convention
(Rich Skorski)
-
That’s Not Normal–the Performance of Odd Floats
(Bruce-Dawson)
-
Playing (with) Video
(Niklas Frykholm)
-
Channel API
(Noel Austin)
-
SQL Server: High performance inserts
(Ted Spence)
-
Why I went back into the studio……
(Kevin Dent)
-
C/C++ Low Level Curriculum Part 8: looking at optimised assembly
(Alex Darby)
-
Xperf Wait Analysis–Finding Idle Time
(Bruce-Dawson)
-
Embracing Dynamism
(Niklas Frykholm)
-
Generating Uniformly Distributed Points on Sphere
(Jaewon Jung)
-
SQL Server Performance: Part 1
(Ted Spence)
-
Software Rasterizer Part 2
(Simon Yeung)
-
The Difficulties of an Infinite Video Game World
(Alex Norton)
-
Inheriting Velocity in Ragdolls
(Niklas Frykholm)
-
Exceptional Floating Point
(Bruce-Dawson)
-
Pushing the Button More Carefully
(Alex Norton)
-
Localization Notes
(Michael A. Carr-Robb-John)
-
Software Rasterizer Part 1
(Simon Yeung)
-
C/C++ Low Level Curriculum Part 7: More Conditionals
(Alex Darby)
-
TDD for legacy code, graphics code, and legacy graphics code?
(Rob-Galanakis)
-
Oxel: A Tool for Occluder Generation
(Nick Darnell)
-
Floating-point complexities
(Bruce-Dawson)
-
Simulating a Loaded Dice in a Constant Time
(Jaewon Jung)
-
Why I hate Test Driven Development
(Rob-Galanakis)
-
Asset packaging in browser-based games
(Rob Ashton)
-
Intermediate Floating-Point Precision
(Bruce-Dawson)
-
PIMPL vs Pure Virtual Interfaces
(Niklas Frykholm)
-
All the nuances of static_cast (and others)
(Jaewon Jung)
-
Getting started with Google App Engine (for .NET developers)
(Jason-Swearingen)
-
C / C++ Low Level Curriculum Part 6: Conditionals
(Alex Darby)
-
Float Precision–From Zero to 100+ Digits
(Bruce-Dawson)
-
The Value of Valgrind
(Max Burke)
-
Unit Testing in Unity
(Poya Manouchehri)
-
Caring by Sharing: The Bitsquid Documentation System
(Niklas Frykholm)
-
Seamless Cube Map Filtering
(Ignacio Castaño)
-
Light Pre Pass Renderer on iPhone
(Simon Yeung)
-
Getting the Projected Extent of a Sphere to the Near Plane
(Jaewon Jung)
-
Running Native Code on Android – Part 2
(Gustavo Samour)
-
Jumping from Web to Mobile, Part 2
(Amos Laber)
-
“Refactor”
(Rob-Galanakis)
-
Comparing Floating Point Numbers, 2012 Edition
(Bruce-Dawson)
-
Sensible Error Handling — Part 3
(Niklas Frykholm)
-
Python’s documentation at your fingertips
(Gustavo Ambrozio)
-
Extracting dominant light from Spherical Harmonics
(Simon Yeung)
-
AltDevConf Programming – Wolfgang Engel, Igor Lobanchikov, and Tim Martin
(Colin Barré-Brisebois)
-
Building a memory system – Part 1: Fundamentals
(Stefan Reinalter)
-
AltDevConf Programming – John McCutchan
(Ignacio Castaño)
-
AltDevConf Programming – Matthieu Laban, Philippe Rollin & Miguel de Icaza
(Ignacio Castaño)
-
Branching strategy is not a remedy for instability
(Rob-Galanakis)
-
Jumping from Web to Mobile, Part 1: Challenges of Cross Platform Game Development
(Amos Laber)
-
C / C++ Low Level Curriculum Part 5: Even More Stack
(Alex Darby)
-
Global Game Jam 2012 Wrap-Up
(Nick Darnell)
-
Component Granularity
(Michael A. Carr-Robb-John)
-
Don’t Store That in a Float
(Bruce-Dawson)
-
Sensible Error Handling – Part 2
(Niklas Frykholm)
-
AltDevConf Programming – Sam Martin
(Colin Barré-Brisebois)
-
Three options for data correctness
(Rob-Galanakis)
-
Abusing C++ with Expression Templates
(Don Olmstead)
-
Stupid Float Tricks
(Bruce-Dawson)
-
Replicating TweetBot’s Alerts and Action Sheets
(Gustavo Ambrozio)
-
Real Men Write Their Own Game Engines
(Gavan Woolery)
-
AltDevConf Programming – Erwin Coumans
(Colin Barré-Brisebois)
-
Inverse Kinematics (2 joints) for foot placement
(Simon Yeung)
-
AltDevConf Programming – Alex Champandard
(Ignacio Castaño)
-
Safer Data Sharing Between Threads
(Mark Lee)
-
Be a Deployment Boy Scout
(Rob-Galanakis)
-
Mathematics for Game Developers 6: Real Numbers part 2
(John-McKenna)
-
Designing for the Untestable
(Claire Blackshaw)
-
5 Tips for Programmer Productivity
(Niklas Frykholm)
-
Tricks With the Floating-Point Format
(Bruce-Dawson)
-
Darwinian_Coding: ( Talking to your AI’s: Universal Language )
(jake kolb v)
-
Game Pre-Mortem
(Charilaos Kalogirou)
-
Reflection in C++, Part 2: The Simple Implementation of Splinter Cell
(Don Williamson)
-
Leaderboard Benchmarking
(David Czarnecki)
-
Skin Shading in Unity3d
(Jon Moore)
-
Code Build Optimisation Part 4 – Incremental Linking and the Search for the Holy Grail.
(Andy Firth)
-
Concurrent World Editing, On the Cheap
(Jonathan Blow)
-
#include <best_practices>
(Don Olmstead)
-
Beyond intrinsics to code idiom
(Andy Thomason )
-
C / C++ Low Level Curriculum Part 4: More Stack
(Alex Darby)
-
Static Code Analysis
(John-Carmack)
-
Top Ten Technologies of 2011
(Bruce-Dawson)
-
Darwinian_Coding: ( Importance of Misunderstandings in Creature Dialog )
(jake kolb v)
-
Platform Specific Resources
(Niklas Frykholm)
-
Walking in the Void
(Michael A. Carr-Robb-John)
-
I HAVE CURED INSOMNIA (with this video on vector-scalar mixing)
(Jaymin Kessler)
-
When Implementing Someone Else’s Algorithm…
(Poya Manouchehri)
-
Microfacet BRDF
(Simon Yeung)
-
Why On Earth Would We Write Our Own Game Engine?
(Yossarian King)
-
Builders and Syncing and Artists Oh My!
(Forrest Smith)
-
C / C++ Low Level Curriculum Part 3: The Stack
(Alex Darby)
-
Absolutely Crackers!
(Steven Tovey)
-
Mathematics for Game Developers 5: Real Numbers part 1
(John-McKenna)
-
Run-debug your way to brittle code!
(Rob-Galanakis)
-
Setting up your own trac and subversion
(James-Mitchell)
-
Running Native Code on Android – Part 1
(Gustavo Samour)
-
Separation of Gameplay
(Alistair Doulin)
-
Darwinian_Coding: ( Giving your Creatures Feelings )
(jake kolb v)
-
Increased Reliability Through More Crashes
(Bruce-Dawson)
-
Even Androids need love: How to make your game play nicely on Android devices
(Tom Killen)
-
A Pragmatic Approach to Performance
(Niklas Frykholm)
-
Intrusive Lists
(John McCutchan)
-
Behavior Tree Entrails
(Bjoern Knafla)
-
Spherical Harmonic Lighting
(Simon Yeung)
-
IEEE 754 multiplication and addition
(Jasper Bekkers)
-
Allocation standards
(Darren-Vine)
-
From the Codeface, a Bug Fixing Story
(Thaddaeus Frogley )
-
The two worlds – a project retrospective
(Rob Ashton)
-
Policy-based design in C++
(Stefan Reinalter)
-
Mathematics for Game Developers 4: Rational Numbers
(John-McKenna)
-
With great powers …
(Robert-Walter)
-
C / C++ Low Level Curriculum part 2: Data Types
(Alex Darby)
-
Test Driven Game Development Experiences
(Alistair Doulin)
-
Darwinian_Coding: ( Implementing Creature Cognitive Replay )
(jake kolb v)
-
A Tale of Two Call Stacks
(Bruce-Dawson)
-
Code Share: Source Censoring
(Niklas Frykholm)
-
Parallel Implementations
(John-Carmack)
-
A Singleton Tale
(Michael A. Carr-Robb-John)
-
Code Build Optimisation Part 3
(Andy Firth)
-
The Many-Worlds Interpretation of Game Development
(Richard Fine)
-
Dual Quaternion
(Simon Yeung)
-
Calculating Crit in a Shooter
(Forrest Smith)
-
I’ll just refactor that…
(Lee Winder)
-
ActionScript Tips for Programmers of C#/C++
(Paul Evans)
-
C++’s unary+ considered useful
(Stefan Reinalter)
-
The Beauty of Software Development
(Sam Martin)
-
Mathematics for Game Developers 3
(John-McKenna)
-
A Series of Lessons in Optimisation
(Tony Albrecht)
-
On Data and Models (or, how a talk by Jeff Ward helped me get back on track)
(Robert-Walter)
-
A Low Level Curriculum for C and C++
(Alex Darby)
-
Becoming A Better Game Programmer
(Alistair Doulin)
-
Kinect, Anthropometry and You
(Nick Darnell)
-
Source Indexing is Underused Awesomeness
(Bruce-Dawson)
-
An Example in Data-Oriented Design: Sound Parameters
(Niklas Frykholm)
-
Code Build Optimization Part 2
(Andy Firth)
-
Cold code – the last bastion of code optimization?
(Andy Thomason )
-
Dual Number
(Simon Yeung)
-
Type Names Matter
(Thaddaeus Frogley )
-
Have you done your 10,000 hours?
(Phil Carlisle)
-
C++ Events
(Christian Schladetsch)
-
A Cough Syrup-Fueled Rant
(Andrew Meade)
-
Naive fallback to canvas from WebGL
(Rolando-Abarca)
-
Darwinian_Coding: ( Cultural_Text )
(jake kolb v)
-
Agile – Specialisations Still Matter
(Lee Winder)
-
Quasi compile-time string hashing
(Stefan Reinalter)
-
Trouble with Triangles
(Sam Martin)
-
Native Client for Dummies
(Erwin Coumans)
-
Making Your Files Merge Friendly
(Nick Darnell)
-
Debugging hard to reproduce bugs
(Charilaos Kalogirou)
-
One size fits all
(Darren-Vine)
-
The Crying Game #3 : Tantrum
(Eddie Cameron)
-
Programming for non programmers
(Fabrice Lété)
-
Using PID Controller
(Simon Yeung)
-
Speeding up sparse data access with bitfields
(Ben Carter)
-
Darwinian_Coding: ( App_Services )
(jake kolb v)
-
How We Review Code
(Lee Winder)
-
Hit me with your Raytracing/Rasterizer stick
(Deano)
-
Upgrading assert() using the preprocessor
(Stefan Reinalter)
-
Beauty in triangles
(Sam Martin)
-
Making your own type id is fun!
(Alex Darby)
-
Idempotent – A Word in the Cloud
(Paul Evans)
-
What Shape is Your Game?
(Luke Dicken)
-
Handy git tips
(Martin Zielinski)
-
Caring by Sharing: Header Hero
(Niklas Frykholm)
-
A Handful of Components
(Michael A. Carr-Robb-John)
-
5 Things You Might Not Know About Visual Studio
(Gustavo Samour)
-
A Pre-commit Checklist
(Ivan-Assen-Ivanov)
-
Getting Started with Sifteo Cubes
(Peter-Smith)
-
I never managed to go left on first try.
(Fabrice Lété)
-
Writing an iPhone Game Engine (Part 6- Performance)
(Simon Yeung)
-
Copying pixels from a pointer to an XNA Texture2D
(Kevin Gadd)
-
Planning Memory Budgets (Part 2)
(Darren-Vine)
-
Meet my dog Chester
(Rolando-Abarca)
-
Never Say Null Again
(Sean Parsons)
-
Why Code Reviews Can Fail
(Lee Winder)
-
How the austrian guy ended up working in the games industry
(Stefan Reinalter)
-
“How did I crash in that function?”
(Chad Bramwell)
-
Don’t use global state to manage a local problem
(Rob-Galanakis)
-
Reflection in C++, Part 1: Introduction
(Don Williamson)
-
How I discovered my favourite templated list class
(Alex Darby)
-
Robust Inside and Outside Solid Voxelization
(Nick Darnell)
-
This code is a mess. Let’s start from scratch again …
(Martin Zielinski)
-
Managing Decoupling Part 4 — The ID Lookup Table
(Niklas Frykholm)
-
The Game Entity – Part V, Future Ponderings
(Michael A. Carr-Robb-John)
-
How to Architect a Worker Thread subsystem, step-by-step (C#)
(Jason-Swearingen)
-
Dynamic Looping with the BASS Audio API
(Mike Slone)
-
Checking for interval overlap
(Fabian-Giesen)
-
Code Build Optimisation Part 1
(Andy Firth)
-
Things I wish I knew earlier
(Zachary Hoefler)
-
Why I Still Think Ray Tracing is the Future
(Gavan Woolery)
-
code completion, a blessing and a curse
(Fabrice Lété)
-
Writing an iPhone Game Engine (Part 5- Audio)
(Simon Yeung)
-
Know your middleware … source code please!
(Andre-Dittrich)
-
Using standard DLLs from C#
(Darren-Vine)
-
Overflowing your Comfort Zone
(Thaddaeus Frogley )
-
How to be a Kick-ass Gameplay Coder
(Andy Bastable)
-
DirectX 11.1
(Wolfgang Engel)
-
The Benefits of Code Review
(Lee Winder)
-
The API from the Black Lagoon
(Ben Carter)
-
RAM fill time
(Drew Thaler)
-
Performance Anxiety 2: You’re doing it wrong
(Kyle-Kulyk)
-
Gathering and Analyzing Data with Django: Part 2
(Don Olmstead)
-
Automation must be a Last Resort
(Rob-Galanakis)
-
Trip Report: Gamefest 2011 – Seattle
(Nick Darnell)
-
A Turing Test for Bots
(Luke Dicken)
-
WebPad: Bring your Own Controller
(Claire Blackshaw)
-
A Simple Roll-Your-Own Documentation System
(Niklas Frykholm)
-
How To Make a Catapult Shooting Game with Cocos2D and Box2D
(Gustavo Ambrozio)
-
Memory allocation pitfalls on multi-core CPUs
(Martin Zielinski)
-
The best of the best, or the lowest of the low ?
(Luke Hutchinson)
-
The Crying Game #1: A Unity3D Dev Diary
(Eddie Cameron)
-
The Games Programmers Play
(Cort Stratton)
-
Interpolation using Radial Basis Functions
(Adrien Herubel)
-
Properties of self-avoiding walks (Part 1)
(Mike Acton)
-
Poll, don’t push
(Fabrice Lété)
-
Writing an iPhone Game Engine (Part 4- Streaming)
(Simon Yeung)
-
Destruction
(Erwin Coumans)
-
In Defence of the Gameplay Programmer
(Andy Bastable)
-
Planning Memory Budgets (Part 1)
(Darren-Vine)
-
Data Validation: Another trick in the bag to catching errors before they cause problems
(Tiffany-Smith)
-
How to improve build stability
(Andre-Dittrich)
-
Leaderboard Hack-A-Thon Post-mortem
(David Czarnecki)
-
Know Your Units
(Drew Thaler)
-
The Tech Artist’s Creed
(Rob-Galanakis)
-
An idea for better watch windows
(Niklas Frykholm)
-
The Game Entity – Part IV, Game Systems
(Michael A. Carr-Robb-John)
-
Who killed Anti-Portals?
(Martin Zielinski)
-
Shader Code for Physically Based Lighting
(Keith Judge)
-
Debugging builds from 6000 miles away
(Darren-Vine)
-
Extending the Unity3D editor
(Richard Fine)
-
Search by a Changelist Description in Perforce
(Jaewon Jung)
-
Optimizing for the instruction cache
(Charilaos Kalogirou)
-
Unity: Some Tips, Some Observations
(Poya Manouchehri)
-
Practical Floating Point
(Andy Firth)
-
Learning Z80 Assembly: Gameboy! (Part 1)
(Zachary Hoefler)
-
Starting the next project by hacking the old one
(Fabrice Lété)
-
Writing an iPhone Game Engine (Part 3- Scripting)
(Simon Yeung)
-
Scripting with no Scripts
(Jonas-Norberg)
-
What’s Eating OOP
(Rob-Galanakis)
-
The Evils of Unity Builds
(Lee Winder)
-
Coding for Playstation 2 – Part 2
(Daniel-Collin)
-
SWIG: Casting Revisited
(Nick Darnell)
-
The Game Entity – Part III, Components
(Michael A. Carr-Robb-John)
-
What you need to give up when going data oriented
(Martin Zielinski)
-
Fixing memory issues in Lua
(Niklas Frykholm)
-
Stencil Buffer Optimisation for Deferred Lights
(Keith Judge)
-
An interesting vertex shader trick
(Cort Stratton)
-
3… 2… 1… GO! Roll-Your-Own Countdown Event Synchronization
(Luke Hutchinson)
-
The demise of the low level Programmer.
(Andy Firth)
-
A Coder’s Musings: What I’d like to see in PS4
(Dotun Rominiyi)
-
A Little Trick To Make Faster Lua Bindings
(Andre Leiradella)
-
Programming the XPERIA Play GPU by Wolfgang Engel and Maurice Ribble
(Wolfgang Engel)
-
Writing an iPhone Game Engine (Part 2- Maya Tools)
(Simon Yeung)
-
Let’s hack on 34 year old code
(Fabrice Lété)
-
Practical MLAA on the GPU – My take
(Jasper Bekkers)
-
Backface culling 101
(Jon Moore)
-
The side effects of programming
(Phil Carlisle)
-
Is it time to ditch your allocator? (Part 2)
(Darren-Vine)
-
A Journey Into Linker Hell, And A Mistake
(Kevin Gadd)
-
Loose Octrees for frustum culling (part 1)
(Daan-Nijs)
-
Get your hands dirty
(Stuart Riffle)
-
Even Error-Distribution: Rules for Designing Graphics Sub-Systems (Part III)
(Wolfgang Engel)
-
Networking, APIs and C preprocessor abuse
(Ben Carter)
-
Hack-A-Thon
(David Czarnecki)
-
A Different Allocator Model
(Lee Winder)
-
The Importance of Vision
(Rob-Galanakis)
-
Gathering and Analyzing Data with Django: Part 1
(Don Olmstead)
-
The unexpected performance of debug builds
(Tom Gaulton)
-
Separating Signal and Noise – Feature Selection in Game AI
(Luke Dicken)
-
Player Motion in a Network Environment (Part 1)
(Andrew Zaferakis)
-
Building your GUI with Gwen
(Martin Pichlmair)
-
The Game Entity – Part II, The Life Cycle and Processing Architecture
(Michael A. Carr-Robb-John)
-
An in-place parsing experiment
(Niklas Frykholm)
-
Debugging Techniques for optimized PPC builds
(Martin Zielinski)
-
Round-Robin Programming
(Cort Stratton)
-
Memory Address Translation
(Luke Hutchinson)
-
When they said “numbers don’t lie,” they were lying
(Richard Fine)
-
Predictable garbage collection with Lua
(Charilaos Kalogirou)
-
What is an “Engineer Architect”
(Andy Firth)
-
A trip through the Graphics Pipeline 2011, part 1
(Fabian-Giesen)
-
A thirst for low-level programming
(Fabrice Lété)
-
Writing an iPhone Game Engine (Part 1- Memory management)
(Simon Yeung)
-
Auto-vectorization for the Masses (part 4 of n): Optimization
(Andre Leiradella)
-
Obligatory FXAA Post
(Jon Moore)
-
Writing Code To Write Code
(Thaddaeus Frogley )
-
Is it time to ditch your allocator? (Part 1)
(Darren-Vine)
-
High voltage retro: CRT emulation for pixel art
(Stuart Riffle)
-
Cross Platform Thread Local Storage (cont’d)
(Julien Hamaide)
-
Simplicity Oriented Programming
(Tomasz Dąbrowski)
-
Real Unusual I/O Slowdowns (Part 3)
(Drew Thaler)
-
Cloud based pipelines?
(Rob-Galanakis)
-
Is It Green Yet? Improving Our CI Process
(Lee Winder)
-
When you can’t SPASM, TREMBLE
(Jaymin Kessler)
-
An AI Curriculum
(Max Dyckhoff)
-
Irradiance Caching – Part 1
(Ignacio Castaño)
-
(Ab)using the C Preprocessor
(Michael Tedder)
-
The unexpected behaviour of debug builds
(Tom Gaulton)
-
The “Gaming Developer” Dilemma
(Savas Ziplies)
-
Students : Game AI vs Traditional AI
(Luke Dicken)
-
The Not Invented Here Manifesto
(Kwasi Mensah)
-
Let me introduce you to Gameduino
(Paul Evans)
-
The Game Entity – Part I, A Retrospect
(Michael A. Carr-Robb-John)
-
Lightweight Lua Bindings — Part 2
(Niklas Frykholm)
-
Synchronous RTS Engines and a Tale of Desyncs
(Forrest Smith)
-
Data-Oriented Behavior Tree Overview
(Bjoern Knafla)
-
Getting Down and Dirty with MESI Caches
(Luke Hutchinson)
-
The Quest for the Ginkgo GUI (2): Going for Gwen
(Martin Pichlmair)
-
Keep your mallocs close, and your related mallocs closer
(Charilaos Kalogirou)
-
Unity3D coroutines in detail
(Richard Fine)
-
A Simple Grass Shader
(Poya Manouchehri)
-
Writing a “Pre-Main” function – Forcing Global Initialization order within VC++
(Andy Firth)
-
Writing an iPhone Game Engine (Part 0 – Introduction)
(Simon Yeung)
-
Auto-vectorization for the Masses (part 3 of n): Semantic validation of SimpleC Programs
(Andre Leiradella)
-
Stick Motion
(Fabrice Lété)
-
Working without an IDE
(Zachary Hoefler)
-
No Look-up Tables: Rules for Designing Graphics Sub-systems (Part II)
(Wolfgang Engel)
-
Threading and Your Game Loop
(Kevin Gadd)
-
From the Codeface
(Thaddaeus Frogley )
-
XNA XML Serialisation Tips
(Glenn Watson)
-
The blunt but useful instrument that is XML serialisation in C#
(Ben Carter)
-
Re-Education (Through Leaderboards)
(David Czarnecki)
-
Ready, Set, Allocate! (Part 6)
(Paul Laska)
-
Your engine is deaf and your tool is dumb. What can you do about it? (Part 1)
(Nicolas Fournel)
-
The Quest for the Ginkgo GUI
(Martin Pichlmair)
-
Top 10 Performance Killers in your AIR Application
(Amos Laber)
-
Platform Abstraction with C++ Templates
(Michael Tedder)
-
Defining a SIMD Interface: Redux
(Don Olmstead)
-
Game Loops on IOS
(Kwasi Mensah)
-
A Word of Warning!
(Michael A. Carr-Robb-John)
-
Old Tricks, New Dogs: Removing Branches
(Luke Hutchinson)
-
Your Argument Is Invalid: Improving OpenGL error messages
(Cort Stratton)
-
Extending the Watching Window in Visual Studio via a Debugger Addin
(Andy Firth)
-
Extending the Watch Window in Visual Studio via EEAddin
(Andy Firth)
-
Emulation Gotchas
(Andre Leiradella)
-
SSAO using Line Integrals
(Simon Yeung)
-
JIT CPU Emulation: A 6502 to x86 Dynamic Recompiler (Part 1)
(Michael Tedder)
-
Dual Issue and Software Pipelining on SPUs
(Luke Hutchinson)
-
Ready, Set, Allocate! (Part 5)
(Paul Laska)
-
Extending the Watch Window in Visual Studio via autoexp.dat
(Andy Firth)
-
Designers are Descriptive; Programmers are Procedural
(Richard Fine)
-
Implementing a True realloc() in C++
(Michael Tedder)
-
Ready, Set, Allocate! (Part 4)
(Paul Laska)
-
Instruction Level Parallelism
(Luke Hutchinson)
-
The Top 6 Misconceptions I Had About Unity
(Richard Fine)
-
Auto-vectorization for the Masses (part 2 of n): Construction of the AST.
(Andre Leiradella)
-
Understanding the Fourier transform
(Stuart Riffle)
-
Ready, Set, Allocate! (Part 3)
(Paul Laska)
-
Trivial Constructors and Destructors in C++
(Michael Tedder)
-
Hosting a Game Server on AWS
(Richard Fine)
-
Set your content creators free with scripting
(Pete Garcin)
-
Auto-vectorization for the Masses (part 1 of n): SimpleC and Abstract Syntax Trees
(Andre Leiradella)
-
Defining a SIMD Interface
(Don Olmstead)
-
Ready, Set, Allocate! (Part 2)
(Paul Laska)
-
Data-Oriented Streams Spring Behavior Trees
(Bjoern Knafla)
-
Simplifying My Workflow
(Szymon Swistun)
-
Creating Camera Based Interactions
(Don Olmstead)
-
Ready, Set, Allocate! (Part 1)
(Paul Laska)
-
if ( simd ) { o_O }, or How to Vectorize Code With Different Execution Paths
(Andre Leiradella)
-
Rendering Technology, What’s Next?
(Szymon Swistun)
-
Software Pipelining (failed video experiment)
(Jaymin Kessler)
-
Shocker: Naive Object-Oriented Behavior Tree Isn’t Data-Oriented
(Bjoern Knafla)
-
Now Where Did I Allocate That?!
(Paul Laska)
-
It’s time to stop using Subversion
(Richard Fine)
-
WebGL – Part 2: In the beginning there was…
(Savas Ziplies)
-
Introduction to Behavior Trees
(Bjoern Knafla)
-
WebGL – Part 1: A new challenger appears…
(Savas Ziplies)
-
Managing Coupling Part 2 — Polling, Callbacks and Events
(Niklas Frykholm)
-
Vectiquette
(Jaymin Kessler)