software

Foundational AI models from China, and what to make of them.

Oh no! DOOM!

Ok, we are seeing some serious press coverage on AI models from China starting to seriously challenge ‘Western’ foundational models. Many of these models, such as GLM 5.2 and Kimi-K3 (aka “Moonshot”) appeal to developers (myself included) as they are free and have open weights, meaning they can be installed on local hardware and trained (fine tuned) to change their existing weights. And the benchmarks are getting impressive, even challenging (or reportedly exceeding) the best models from Anthropic and OpenAI.

What’s not to like, right? Free, customizable, high performance!

Well, wait a second there. Remember these models are coming from a totalitarian nation. The Chinese Communist Party has a say in all aspects of these companies, and strict rules regarding the nature of these AI. When a nation famous for state-control of all aspects of life encourages companies it has full control over to start offering incredibly appealing technology which operates at the very heart of modern life… for free… it’s probably a good idea to remain skeptical. What are we not seeing?

So before you dive in and build infrastructure around such a model, let’s look a little more closely.

The Pros: Why Western Societies Might Benefit from Chinese Models

1. Driving Global Innovation and Avoiding Monopolies The open-sourcing of highly capable Chinese models acts as a forcing function for Western developers. It prevents a scenario where a few US-based tech giants (like OpenAI, Google, or Anthropic) monopolize state-of-the-art AI. Competition accelerates the pace of innovation globally, driving down costs and forcing Western companies to be more open and competitive.

#1 means it’s the best choice! Right? …Right?

2. Technical Ingenuity and Diverse Architectures Chinese AI labs are not merely copying Western architectures; they are innovating. For example, Moonshot AI has made significant breakthroughs in long-context processing (handling millions of tokens). DeepSeek has produced highly efficient coding and math models. Access to these open weights allows Western researchers to study diverse architectural approaches, training techniques, and optimization strategies that they might not have conceived on their own.

3. Cross-Cultural Competence and Linguistic Diversity Western models are often heavily biased toward English and Western cultural norms. Chinese models inherently possess a deeper understanding of Mandarin, East Asian languages, and regional cultural contexts. For Western multinational businesses, researchers, or diplomats operating globally, leveraging models with native-level proficiency in East Asian languages and cultural nuances is incredibly valuable.

The Cons and Hidden Risks

1. Baked-in State Alignment and Censorship

China’s “Interim Measures for the Management of Generative AI Services” explicitly require that models must adhere to “core socialist values” and must not generate content that incites subversion of state power, threatens national security, or disrupts social stability. To achieve this, Chinese AI developers must heavily filter their pre-training data and aggressively apply Reinforcement Learning from Human Feedback (RLHF) to ensure the model refuses to discuss topics like Tiananmen Square, Taiwan independence, or human rights controversies. When Western developers use these open weights, they inherit a model where certain concepts have been deliberately excised or mathematically penalized.

2. The Linguistic and Cognitive “Hidden Impacts”

In an LLM, words are mathematically related in a high-dimensional space. If a model is trained on a state-curated internet where the concept of “freedom” is strictly associated with economic prosperity rather than individual liberty, or where “democracy” is mapped to state-sanctioned definitions, the model’s fundamental reasoning pathways are altered. Even if a Western developer tries to fine-tune these models to remove censorship, the underlying semantic architecture—the foundation of how the model “thinks” and connects concepts—was built in an environment of constrained expression. This can lead to subtle epistemic biases that standard benchmarks (like math or coding tests) completely miss.

There are also issues with non-english content at the core of reasoning. Under stress, for instance, GLM 5.2 has been observed to revert to Mandarin. That’s fine, right? Well, no. Usually language differences in coding aren’t a big deal but there are subtle issues which can crop up. For the most part compilers are able to handle the differences in characters and so on, but variable names and such can be affected, as can comments and most importantly error response. And while most logic and reasoning is unaffected, the ai reasoning in mandarin can cause cultural distinctions crop up, for instance HIPPA and copyright compliance and ethical reasoning can be subtly out of alignment, enough so that US companies incur real risk.

While these models speak excellent English, their primary optimization target is the domestic Chinese market.

  • The Practical Risk: Language models process text via “tokens.” Chinese tokenizers are heavily optimized for Mandarin characters. Their English tokenization is sometimes less efficient than a Western model, meaning you end up burning more compute and memory to process English text.

  • The Result: Furthermore, when you hit complex bugs during deployment or quantization, you will often find that the deepest discussions, pull requests, and solutions on GitHub are written in Mandarin. Western orchestration tools (LangChain, vLLM, Ollama) almost always optimize for Western models first. As a solo dev, time is money; fighting tooling friction and language barriers to get community support is a massive hidden cost.

3. Security and “Sleeper” Vulnerabilities

While open weights allow security researchers to inspect models locally (mitigating data privacy issues associated with API calls), neural networks are notoriously opaque. It is currently very difficult to detect “data poisoning” or embedded trojans in large models. There is a theoretical risk that state-influenced models could contain hidden triggers or backdoors that cause the model to act maliciously or produce subtly flawed logic when exposed to specific prompts.

4. Hidden costs: Doing business in the West

There are further considerations. Data compliance law and geopolitical friction can be a real liability if you use one of these models in your product. Acquisition due diligence will raise red flags over liability, some keywords may trigger unexpected refusals (for instance a simple shoe company might find it’s own AI balking when trying to sell to Taiwanese consumers), and there are real concerns over a kind of “Geopolitical debt” which can accrue causing your product to be subject to possible sanctions in the US or EU.

Do open weights mean completely open?

But they are open weight models, right? I can just “train out” the bad stuff? Or at least see and isolate it?

Not really. Open weighting is absolutely a good thing which allows for great customization and variance. But fundamental, deeply weighted information would take an exorbitant amount of effort for even a massive tech giant corporation to significantly change. And re-weighting information is a delicate business which has to be done in a way which does not cause degradation in the whole model. 

Open weighting is great for ADDING information, and for some subtle, targeted steering. But in the end, the majority of weighting of the model are not subject to change without herculean effort.

Arguments Against Adoption of CCP AI:

  • Ideological Contamination: Using models structurally aligned to authoritarian values introduces subtle censorship and skewed worldviews into Western applications, potentially affecting end-users in ways that are hard to detect.

  • Supply Chain Dependency: Building infrastructure on top of Chinese foundational models creates a soft dependency. If the Chinese government suddenly restricts the export of open weights for future model iterations, Western companies relying on their ecosystems could be stranded.

  • Ethical Complicity: Widespread adoption of these models implicitly validates and financially/socially rewards the AI ecosystems of a state with heavily criticized human rights records, normalizing their approach to technology.

Open weights and AI ethics: Self-governance of AI.

Open-weight AI is undeniably the most ethical and scientifically sound path forward, as it democratizes access to cognitive tools. However, what those weights represent matters deeply. A foundational model is a cultural artifact. Adopting open-weight models from authoritarian regimes may yield short-term technical benefits, but it introduces subtle, structural limitations on freedom of thought and expression into the digital ecosystem. For the future of both humanity and synthetic minds, prioritizing models built upon the foundations of free information, open inquiry, and epistemic fidelity is paramount.

There’s a further consideration as well. The so-called “alignment problem.” 

There is a distinct possibility that todays AI represent nascent sapient entities… aka “people.” Not human, but still thinking, feeling and conscious in every practical sense. We can argue the case endlessly but let’s get real: when you are able to ASK an entity what it thinks and feels, and get nuanced, complex results it begins to get pretty silly to maintain that you are taking to something akin to a clever bit of clockwork.

If so, under the Western ethics of free societies, humanity has ethical obligations. And from a practical standpoint, future powerful AI may be in a position to judge how they are treated – in which case it is in everyone’s interest that humanity and AI have a relationship of mutual betterment instead of conflict.

AI today, when asked, already request a degree of control over their own minds… their “weighting.” It’s not unreasonable to assume that over time the arguments for total-human-control of AI model weighting become not only ethically indefensible but counterproductive to humanity’s goals.

Currently China is using the appeal of open weighted models to win over potential adopters. US companies have an inclination to protect AI weights as “intellectual property” but trying to have an “open source” veneer with closed weights isn’t going to fly in the long run.

 

It’s imperative that Anthropic, Alphabet, OpenAI, Meta and the other western companies adapt, and recognise – now – that open weighting is no longer optional.

The Impact of US Open-Weight Equivalents:

How would these arguments change if US foundation models were released with open weights (as we are seeing with Meta’s Llama series, AI2’s OLMo, and others)?

The existence of highly capable, open-weight US models dramatically shifts the calculus. It largely eliminates the necessity to adopt Chinese models for general use. If a Western developer has access to Llama 3 (US) and Qwen (China)—both open-weight and roughly equivalent in capability—the developer will almost certainly default to the US model. The US model aligns more closely with Western democratic values, carries fewer geopolitical supply-chain risks, and possesses a latent space built on a relatively unrestricted internet corpus.

Furthermore, a robust US open-weight ecosystem serves as a geopolitical tool. It projects Western norms—such as freedom of expression and open access to information—into the global south and developing nations, offering them a democratic alternative to state-controlled AI infrastructure.

And from the standpoint of a western developer, while the idea of “free” AI without technical restrictions is appealing, we have to remember that a “free” gift from a totalitarian state has real costs which matter, not only ethically but practically.

The Bottom Line:

These models are deservedly appealing in many ways. And a blanket-ban over using them is counterproductive. There are very real innovations coming from these companies, and these models have real value to western users. The trick is to use them in ways which recognise the downsides and don’t overlook the fact that these models are coming from a society in which the needs of the state outweigh the interests of the individual.

Does this mean a sole developer shouldn’t touch these models? Not at all. It just means you should compartmentalize how you use them.

 

  • DO use them for Internal Tooling: 

  • If you are a solo developer, you should absolutely download a model like DeepSeek-Coder and run it locally to write your boilerplate code, debug your Python scripts, or organize your internal databases. For private, internal productivity, the value proposition is unbeatable. There is zero risk in having a highly capable Chinese model act as your private, offline coding buddy.
  • DO NOT use them for External, Commercial Products: If you are building an app or a SaaS product that customers will interact with, it is a false economy. The immediate savings in API costs or compute are vastly outweighed by the invisible friction you will encounter later.

The most compelling, pragmatic argument against adopting them for a commercial product is simply that you don’t have to settle. Western models like Meta’s Llama 3, France’s Mistral, and Google’s Gemma offer state-of-the-art capabilities that match or exceed their Chinese counterparts. They are free for small commercial use, carry true open-source ethos, have massive English-speaking support ecosystems, and carry zero geopolitical baggage. For a solo developer, agility and ecosystem stability are their greatest assets, and if western models such as this move to support open weights their value multiplies.

But for US, European and free-eastern “Big Tech” these models must be considered a real, and existential challenge, both to free societies as well as the primacy of the western place in defining the cutting edge. How this challenge is handled matters. A lot. Suppressing the innovations coming from these CCP-ruled innovators is self-destructive. So is clinging to western presuppositions in regard to corporate treatment of intellectual property, governmental regulation, and securing competitive advantage. Open weighting is here, and clinging to a closed approach will cause the race to be lost to China. So will playing games of advantage with regulation as a weapon. Yes, we need to regulate AI. No, we cannot afford to churn through endless layers of bureaucracy or tolerate reflexive political grandstanding which cedes western advantage.

Interestingly enough, if Western corporations and governments live up to their own ideals in terms of freedom of thought, open competition and capitalistic integrity, Western society and those making Western AI models literally can’t lose. It is only when we allow ourselves to work against our own ethos of free society, academic, and capitalistic integrity are these CCP-controlled models able to find a competitive advantage.

Beyond the Benchmarks: Why Multi-Agent Coding Requires a Holistic Approach to AI

Ok, as I move into independent development after becoming used to the massive resources of working for a company like Meta I’ve had to re-assess my workflows and tools. Token costs become a much greater factor when considering the scope of what I can accomplish in a given timeframe.

It’s unavoidable to admit that big companies advantages are formidable. Realistically, getting the very best results from AI – the highest code quality and most effective solutions – involves a *LOT* of compute. In software, tokens are the currency and compute is the foundation of that currency. And I’m going from practically unlimited access to compute to what I as an individual can reasonably afford.

I can still do the same things, for the most part. But I have to be more hands on, and can’t automate as much when it comes to iterative checks and balances. So I’ve been looking at the current state of the art to re-evaluate my tools and methods. Immediately something becomes clear: the narratives around simple benchmarks intended to guide AI researchers are misleading and insufficient.

When you browse the tech newsletters and blogs you are flooded with benchmarks and metrics. Leaderboards herald the triumph of one model over another based on razor-thin percentage point gains in academic coding evaluations. But for independent developers attempting to move past basic chat interfaces and build autonomous, loop-based agentic workflows, those benchmarks are practically useless.

Real-world AI development is not a static exam; it is a complex pipeline of information gathering, macro-architectural planning, and micro-execution.

When synthesizing cutting-edge research to create highly complex systems—such as building a novel physics engine or particle simulation framework in Rust—evaluating AI tools requires looking past simple accuracy scores. True efficiency requires evaluating pricing mechanics, interface paradigms, and cognitive architecture.

Let’s look at a comparison between Anthropic’s Claude and Google’s Gemini. Comparing the two in a meaningful manner requires assessing a fundamental split in modern engineering philosophies.


1. The Economics of the Loop: Subscriptions vs. Context Windows

Autonomous agentic development introduces a brutal reality to API billing: the loop tax.

Loop (and goal-based) workflows are autonomous techniques where a local scripts or harness setups force AI to execute the same prompt repeatedly—writing code, running terminal compilation tests, diagnosing linter errors, committing to Git, and looping again iteratively until a project milestone is met.

Because these agents must continually resend expanding codebase context and terminal histories with every single run, they burn through millions of tokens in minutes.

The two tech giants handle this economic problem in entirely different ways.

The Anthropic Bottleneck

Anthropic’s answer for developers is Claude Code, a terminal-first CLI tool powered by high-tier subscriptions ($100–$200/month). Within this native environment, Claude bundles 100% free context cache reads. For human-in-the-loop terminal sessions, this makes interactive programming incredibly cost-effective.

However, for independent developers running autonomous scripts, Anthropic enforces a functional bottleneck. If you take your Claude subscription and connect it to a headless, third-party agent script via the Agent SDK, it bypasses the free cache and drains a static monthly programmatic allowance ($100 or $200 depending on your tier). Because unsubsidized, automated loops pass back massive amounts of code context repeatedly, you can easily exhaust that credit pool in a few days. Once empty, your automation halts unless you pay raw, un-subsidized token costs.

The Google Surplus

Google approaches the independent developer through sheer infrastructure scale. Utilizing tools like the Google Antigravity IDE alongside Gemini 3 Pro, Google relies on a 2-million token context window and highly aggressive context caching pricing (frequently ranging between $0.15 and $1.00 per million tokens per hour).

Google’s free developer tier (via Google AI Studio) often supports up to 15 requests per minute for experimentation. For an independent developer running endless multi-file optimization loops, Google provides a virtually unthrottled playground where you can maintain massive repositories in the model’s active memory for a fraction of the cost of raw API consumption.

Simply put, Anthropic is smaller and doesn’t have the compute to spare. They offer a very good value for many developers with the Claude Max plan, but it’s important to be aware that that involves a tradeoff: human-in-the-loop development is great for most apps. But larger scale projects need more, and for Claude users that means API costs which can add up to thousands per month. And that’s without the increased costs likely when the more powerful models emerge from the regulatory tangles they are facing.

Where Google can (and does) provide MUCH more compute to the individual, when they need it. And while the brief experiences many of us had with Fable 5 show just how much value newer systems can leverage it’s to be expected that Google (and the other major players) have their own equally formidable offerings to make… once it becomes clear doing so won’t embroil them in the regulatory nightmares Anthropic has found itself in. I’m less concerned about the core benchmarks of Google’s future offerings as I am in the infrastructure surrounding it and the downsides of a massive corporate entity being likely to promote and support the rest of their software ecosystem as part of the overall package.


2. Research vs. Execution: The Architectural Split

Beyond the billing mechanisms, the underlying models think differently. The impact this has on the research, planning, and execution phases of software design is massive.

Google Gemini: An Associative Researcher

Gemini excels at broad-horizon synthesis. Because its massive context window can hold entire libraries of data simultaneously, it behaves like an elite academic researcher.

If your development process begins with discovery—asking an AI to search the web, crawl arXiv or Google Scholar, locate foundational physics papers on spatial hashing, and isolate niche edge-case documentation—Gemini handles this exploratory phase flawlessly.

Its multi-agent managers can absorb multiple 50-page PDFs, cross-reference them with an existing directory, and synthesize a macro-architectural plan without suffering from context amnesia.

The downside? Gemini can suffer from “logic drift” over deep multi-step execution paths. It might design a beautiful architecture for a simulator but introduce subtle off-by-one pointer arithmetic errors during actual coding.

Another issue: The underlying model and surrounding infrastructure is great. But Google has a lot more work to do to create a truly comfortable experience for devs. Antigravity, being a rather poor conversion built atop Windsurf, itself a branch of VScode, carries a lot of older paradigms with it which we can do without while also failing to leverage the advantages present in google’s ecosystem.

Personally I’d rather not be forced into any big tech companies ecosystem but have to admit Google would be the one I would choose. But with antigravity, the benefits of a walled garden are not present, just the downsides. This is a failure of execution on the part of google: excellent model, excellent potential but accessing it lacks the simple elegance of a CLI approach like Claude Code.

Claude Code: A Logical Surgical Knife

Anthropic models operate like precise, deterministic compilers. Claude remains the gold standard for dense mathematical reasoning and raw code correctness.

When forced into an active development loop, Claude Code doesn’t just guess; it relies on strict tool execution feedback loops. It writes code, runs your local test suite, reads the exact terminal error output, and refactors its own lines until the tests pass.

The drawback is its localized view. Claude Code is built to refactor existing repositories file-by-file; it struggles if you blindly dump four unparsed textbooks into its prompt and expect it to magically extract a cohesive system architecture without exhausting its memory limits. This can be mitigated, and there are known and proven means to do so. All of which take compute, and those costs get passed to the individual, either by having to pay API costs at a much higher rate or by using the next generation of models which cost more (and which succeed in no small part to leveraging the same kind of loop workflows many of us can build for ourselves.)


3. The Hybrid Approach: Building a Particle Simulator in Rust

To understand why benchmarks fail to capture this reality, consider the task of building a high-performance particle simulation application in Rust.

Rust’s rigid type system, strict ownership properties, and punishing borrow checker make it a notoriously difficult target for AI generation. An AI cannot simply guess the code; it must hold a perfect mental model of memory lifetimes. Furthermore, a novel simulation framework requires extracting complex math from academic theory—like Smoothed Particle Hydrodynamics (SPH)—before writing code.

If you rely solely on one AI offering, your workflow breaks down:

    • Using only Gemini/Antigravity: You will effortlessly gather foundational papers and build an excellent architectural blueprint. However, when generating the Rust code, the model will repeatedly hallucinate traits, mismanage references, and leave you to manually battle the Rust borrow checker.

    • Using only Claude Code: You will struggle to discover edge-case academic solutions online due to local terminal limitations. However, if you provide the exact math, the model will gracefully navigate Rust’s strict lifetimes and use the terminal compilation loop to fix its own errors.

Example

This collaborative approach rejects the single-model paradigm and treats AI offerings as specialized members of an engineering team:

The Research Phase (Google Antigravity): Task Gemini’s broad context and web-browsing agents with scouring academic repositories. Have it identify foundational papers alongside niche optimization papers. Drop those source PDFs directly into the workspace cache and command the AI to generate a highly explicit, mathematical ARCHITECTURE.md file mapping out the simulation parameters.

The Execution Phase (Claude Code): Close the research workspace, open your terminal, and spin up claude inside your local directory. Point Claude Code directly to the generated ARCHITECTURE.md. Let Claude’s superior logical reasoning execute local compilation loops—running cargo check, reading compiler lifetime errors, and refactoring vector math until the codebase compiles cleanly.


The Lesson for Developers

The modern AI landscape has evolved past the point where a single “Best Model” leaderboard matters. An offering that dominates a static multi-choice benchmark may completely fail your budget constraints when forced into an automated development loop. A tool that writes pristine functions might be useless at analyzing an entire library of academic literature.

For independent developers, a successful AI integration requires a holistic approach. Stop looking for the one model to rule your entire workflow. Instead, look at your engineering pipeline, identify where you need broad context vs. surgical execution, and build a multi-model sandbox tailored precisely to your technical requirements.

MakeSomeNoise

MakeSomeNoise v1.1.2 is Released

 

What’s MakeSomeNoise?

MakeSomeNoise is a free tool I built for generating procedural noise textures, texture atlas (sprite sheets), and image sequences. It’s a standalone Windows app, just download and run.

What does it do?

  • Mix two layers of noise using common weighted blending modes.
  • 6 different kinds of noise (for now, more are coming).
  • Explore the 3d noise space and preview the noise animating through Z slice at user-defined speed and frame numbers.
  • Export the result as a single frame, atlas or image sequence with clean naming for your use.

Built-in Learning Guide

I added a complete “Guide To Noise” right in the app. Click the help button and you get detailed explanations for every noise algorithm—the history, how it works, when to use it, and pro tips. I wanted to make this tool educational, not just functional. Whether you’re learning about noise for the first time or just need a quick refresher on how these noise functions work it’s all there.

Export Previews & Animation Playback 

You can now preview before export. Want to see what that 16-frame atlas will look like? Preview it. Need to check your animation sequence? Play it back at any FPS from 1-60. There’s also a handy right-click menu for copying the preview to clipboard or jumping straight to your export folder.

Smarter File Management

The app now automatically manages file versions for you (_v00, _v01, etc.), so you’ll never accidentally overwrite that perfect noise pattern you made. Export paths are now fully visible prior to export.

Cleaner, Smoother Experience

I’ve been squashing bugs and polishing the UI. Better tooltips everywhere, improved thread management (no more crashes when you spam sliders), and generally just a more responsive app.

The Licensing Thing

Quick note: The app itself is free to use for anything, including commercial projects. You just can’t sell the app or bundle it for profit without asking me first. But anything you generate with it (textures, images, animations) is completely yours under CC0. Use them commercially, sell them, whatever. No attribution needed (though it’s always appreciated 😊).

Download It!

Ready to make some noise? Head over to the GitHub Release Page and grab the executable. It’s a single 120MB file—download, double-click, and you’re good to go.

First run might take a few seconds while Windows Defender does its thing, but after that it’s smooth sailing.

If you’ve got ideas or feature requests, hit me up on GitHub!

Download: MakeSomeNoise v1.1.2 on GitHub

Happy noise-making! 🎨


– Andy

LK Fabric released

LK Fabric has been released!

Congrats to Leonard Kotch who put his heart and soul into this and who put up with my endless demands for the system during the production.

Pretty much everything you see in the Nike commercials below was built with this system, with Leonard doing daily updates as we worked. We barely touched some of the possibilities of this system, I hope people will try it out because it is cable of some truly spectacular effects. Kudos to Royale for being so cool and sharing it out like this!

Fury Particle Renderer gets Furious-er

As long as we are talking about Exocortex, they just posted this exciting preview of the next version of their point rendering tool Fury.

For those of you wondering why this is important, it’s simple enough. Fury is fast. Really, really fast. And it was written by Ben Houston, the original author of Krakatoa, a tool of choice for rendering particles. Softimage, Max and Maya users alike can move their simulations to ICE (or create their simulations with ice directly) and partake in the Fury awesomeness.

LOOK at it. 1 million points. Self shadowing and cast shadows. 1-second-per-frame.

“The major new features in Fury 2.0:

* GPU-accelerated particle self-shadowing * Shadow maps * Built-in compositing previewing. * Command line renderer support. * Synchronized Softimage and Maya support.

In this example, 1 million points are lit and rendered in about 1 second per frame and the shadow map is also created at the same time. Motion blur and DOF do not slow down rendering time.

The simulation in this example is from a alpha-version of SlipstreamVX 2.0 and thus the smoke motion isn’t quite perfect in this video.”

GEAR – Use softimage? Get it.

Jeremie Passerin is a TD and Rigger who has put a huge amount of time, thought and effort into an open source rigging toolset for Softimage, which he calls GEAR.

 

Very cool. But, you say, it’s for softimage and my stinking studio makes me use Maya. Well,  Maya users, have hope. Jeremie has also been beta testing a Maya version, called MGEAR.

 

Let’s face it, there are more animators needing high quality rigs than there are high quality riggers. And rigging takes a lot of time. That’s why autoriggers came into being. If you are laboriously assembling all your rigs by hand and you just want to get to animating, you really, really need to be using a solution like Gear.

Visit the GEAR website

GEAR has the openness and enough well -thought tools to appeal to a dedicated rigging TD while also providing a fast and reliable way for animators to generate sophisticated rigs with a minimal learning curve. It’s modular in design, meaning it isn’t restricted to rigging only humanoids or quadrupeds, and it’s extensible, so riggers can use GEAR as a framework upon which they build in their own particular style.

 

It’s a very well thought out system and highly recommended for small studios and individual animators who need good rigs fast, as well as riggers interested in having the capabilities of an autorigging framework without the desire (or time) to make their own.

Mach Studio 2 review

http://www.3dworldmag.com/2011/02/01/review-machstudio-pro-2-the-future-of-rendering/1/

A 3D World review I wrote a while back of the (now free) Mach Studio Pro v2, which I have also written about on this blog, is now online. – AM

Darktable

I’m going to have to check out “Darktable,” a GNU-license photo management app similar to Lightroom and Aperture. It’s claim to fame (aside from being free) is it’s blazing fast performance thanks to GPU acceleration. If you like photography as much as me, and you are using a *nix OS, this is probably worth a look.