First Prune: Celebrate One Year of Pruna OSS

One year in, and what a year it has been!

This month, we’re celebrating First Prune, the first anniversary of Pruna OSS. As a way to thank everyone who has been part of the journey, we’re giving 60 credits for the Pruna Inference API to contributors who join the celebration.

To take part, you just need to get assigned an issue and open a PR by April 30.
You can check the issues here and find the details in the PR template.

We open-sourced the Pruna package with a clear ambition: to make AI optimization easier, more effective, and a lot more practical. Since then, the project has grown quickly, and every step has pushed us closer to that goal: bringing state-of-the-art optimization to more people. And honestly, we feel like this is just the beginning.

In this blog, we’re taking a look back at everything we’ve built, learned, and shared over the past year.

How It Started

A year ago, Pruna started from a frustration we kept running into: optimizing AI models was powerful, but far too painful. Teams were wasting too much time stitching methods together, tuning everything by hand, and dealing with complexity just to make models faster, smaller, and cheaper. But AI efficiency shouldn’t be this hard.

That is why we built Pruna: one package designed to help developers compress, evaluate, and optimize models in a simpler, more practical way.

Open-sourcing Pruna was just the beginning, and, of course, it came with challenges. We had to improve documentation, add more compatibility, and make the package smoother to work with. But step by step, with the Pruna team and the support of contributors, we made it better.

Over time, Pruna has gained more visibility through conversations with the community, shared OSS models on Hugging Face, and more people are building efficient models.

What We Built

Pruna is a model optimization framework to deliver faster, more efficient models with minimal overhead.

from diffusers import DiffusionPipeline

from pruna import SmashConfig, smash
from pruna.data.pruna_datamodule import PrunaDataModule
from pruna.evaluation.evaluation_agent import EvaluationAgent
from pruna.evaluation.task import Task

# Load the model
model = DiffusionPipeline.from_pretrained("segmind/Segmind-Vega")

# Create and configure SmashConfig
smash_config = SmashConfig(["hqq_diffusers"])

# Smash the model
optimized_model = smash(model=model, smash_config=smash_config)

# Evaluate the model
metrics = ["clip_score", "psnr"]
datamodule = PrunaDataModule.from_string("LAION256")
datamodule.limit_datasets(5) # You can limit the number of samples.
task = Task(metrics, datamodule=datamodule)
eval_agent = EvaluationAgent(task)
eval_agent.evaluate(optimized_model)

# Run inference
optimized_model.set_progress_bar_config(disable=True)
optimized_model.to("cuda")
optimized_model("A serene landscape with mountains").images[0].save("output.png")

Just with these few lines of code, you’ll be loading, compressing, evaluating, and running your model. And to reach this point, a lot happened this year.

We shipped major upgrades, added more algorithms, improved composability, and kept building tools and resources around efficient AI. Step by step, that made Pruna meaningfully stronger and more useful in practice.

Over the past year, that work translated into:

13 releases
28 contributors
12 algorithm families
43 algorithms

We kept building beyond the core package, too, with everything from educational content to real optimized models published in Hugging Face. We also kept improving docs, tutorials, blog posts, and learning resources, such as the AI Efficiency Course and Awesome AI Efficiency. All of it moves toward the same goal: making AI efficiency easier to learn, easier to use, and easier to apply.

Access our OOS optimized models: https://huggingface.co/PrunaAI
Check our educational resources: https://github.com/PrunaAI/ai-efficiency-courses and https://github.com/PrunaAI/awesome-ai-efficiency

Community and Contributions

Pruna did not grow alone this year. The community played a huge role, and a big part of this journey was building with people.

Feedback from the community helped us improve the package, shape resources, and keep moving in the right direction. Every PR, every issue, every test, and every conversation helped make Pruna better.

We also wanted to keep that connection alive beyond GitHub, so we joined different events and organized our own, including AI Efficiency Meetups and webinars. If you want to follow the journey and be part of what’s next, don’t hesitate to join us.

Lessons Learned and What’s Next

If this year taught us one thing, it is that building in the open makes everything better and that useful optimization wins.

So that is exactly where we are heading next: more algorithms, better usability, stronger integrations, and a smoother experience for anyone who wants to optimize models without the usual pain.

The first year was about laying the foundation. The next one is about going bigger. Thank you for being part of the journey this year.