raylibtech.itch.io

What is raylib technologies?

raylib technologies is the itch.io storefront for a small suite of game-development and asset-pipeline utilities built around the raylib ecosystem. The tools share a common pitch: they are self-contained, portable, and designed to slot into a production pipeline through a command-line interface while still offering a friendly graphical interface. The page describes them as "handmade custom tools" and invites visitors to ask about a specific tool if they don't see what they need.

The catalog splits into two broad groups:

• Paid desktop tools ($9.95–$19.95): rInstallFriendly (installer-package creator), rTexViewer (texture viewer, editor, and image board), rTexPacker (texture packer and font-atlas generator), rImageShield (image message embedder), rQuizzer (quiz tool), rIconPacker (icon packer and extractor), and rrespacker (rres resource packer).
• Free browser tools: rFXGen (sound-effect generator) and the raygui trio — rGuiStyler, rGuiIcons, and rGuiLayout — for editing styles, icons, and layouts.

Who it is for

The practical audience is indie developers, technical artists, and small teams already using raylib or raygui, or anyone who wants lightweight asset utilities without a large engine attachment. The command-line emphasis matters most for teams automating builds: a texture packer or resource packer that runs headlessly can be scripted into a CI step, while the same tool's GUI helps an artist check results interactively.

How to choose

Start with the free browser tools if you only need to generate sound effects or design raygui interfaces — there is no commitment and no install. Move to a paid desktop tool when the task becomes repetitive or needs to run inside an automated pipeline. If your need is narrow or unusual, the page explicitly invites a conversation about custom tools, which is a reasonable route for studios with a specific format or workflow in mind.

A sensible next step is to open one of the browser tools that matches your immediate task, such as rTexPacker for texture atlases, and evaluate whether the output fits your engine before considering the paid desktop counterparts.

Which raylib technologies tools can I try for free in my browser before buying?

You can try nine tools directly in the browser without paying: rTexViewer, rTexPacker, rImageShield, rFXGen, rQuizzer, rIconPacker, rGuiStyler, rGuiIcons, rGuiLayout and rrespacker. The one paid tool with no browser option listed is rInstallFriendly.

Browser-tryable vs. paid-only

Several of these are listed with a price (for example, rTexViewer, rTexPacker, rQuizzer and rrespacker at $19.95, and rIconPacker at $9.95), but the page also offers a browser run for each. That combination is the useful part: you can evaluate the workflow before deciding whether to buy the downloadable, pipeline-integrated version.

How to decide what to trial first

Match the trial to the job you actually have:

• Game asset pipeline: start with rTexPacker (atlases) and rrespacker (resource packing), since these affect build output.
• UI work with raygui: rGuiStyler, rGuiIcons and rGuiLayout form a natural set — style, icons, then layout.
• Audio or image content: rFXGen for sound effects, rImageShield for embedding messages in images.
• Teaching or assessment: rQuizzer.
• Desktop distribution: rInstallFriendly is the one to consider without a browser trial, so treat it as the higher-commitment purchase.

A practical next step: open the browser version of one tool that matches your current task, run a small real asset through it, and note whether the interface and output fit your pipeline. If the browser version handles your case, that tells you more than any feature list.

The developer, raylib technologies, also maintains a main site at raylib technologies and a community profile on itch.io, where these tools are hosted.

How do the paid tools like rTexPacker and rTexViewer integrate into a game development pipeline via command line?

raylib technologies' paid tools are built around the idea that the same executable can be driven by a mouse or by a script. rTexViewer, rTexPacker, rImageShield, rQuizzer, rIconPacker and rrespacker are each described as "simple and easy-to-use" utilities with a "powerful command-line and a user-friendly interface," so the intended pipeline pattern is: open the GUI to experiment, then copy the equivalent command-line invocation into a build step.

What that looks like in practice

For a texture pipeline, the typical division of labour is:

• rTexViewer — inspection and light editing: check a sprite sheet, adjust or preview an image, and decide what needs fixing. This is the human-in-the-loop stage.
• rTexPacker — the automated stage: pack multiple source images into an atlas and generate a font atlas, run headlessly from a script so artists never hand-place sprites.
• rImageShield — embed a message into an image, useful for asset marking or provenance before shipping.
• rIconPacker — pack and extract icon sets, again scriptable for consistent multi-size output.
• rrespacker — bundle resources into an rres file for the runtime to load.

A concrete build-step scenario

An artist exports 40 individual PNGs. A pre-build script calls rTexPacker to combine them into one atlas plus a data file, then the build copies that atlas into the game's asset folder. If a texture looks wrong at runtime, the developer opens rTexViewer on the same file to inspect it rather than re-running the whole pipeline. Because the tools are described as self-contained, portable and multiplatform, the same commands can run on a developer's machine and on a CI runner without installing a separate runtime.

Decision criteria

• If your team already has a custom atlas format or a third-party packer wired into the engine, the value here is mainly the GUI-plus-CLI consistency, not raw feature depth.
• If you want artists to iterate without a programmer, the "Run in browser" builds let them preview several of these tools without installing anything.
• If your pipeline is fully automated and never needs visual inspection, the paid GUI tools matter less than the command-line behaviour — verify the exact flags and exit codes before committing.

For the current tool list and any documentation, start at raylib technologies; the vendor's own site is raylibtech.com. If you use the raygui ecosystem, the free style, icon and layout editors (rGuiStyler, rGuiIcons, rGuiLayout) are the natural companions to the paid asset tools.

What is the difference between rTexPacker and rIconPacker for creating texture atlases and icon packs?

rTexPacker is the general-purpose texture atlas tool; rIconPacker is the narrower icon-specific packer and extractor. Both come from the same small-tool family, raylib technologies, and both are described as "simple and easy-to-use," so the choice is mostly about what you are packing and what you need to get back out.

The practical split

• rTexPacker — packs textures and generates font atlases. It is the one to reach for when your source material is a folder of sprites, UI images, tiles or a bitmap font, and your goal is a single atlas plus the coordinates your engine needs.
• rIconPacker — packs icons and can also extract them. The extraction side matters if you already have a sheet or icon set and need individual files back out, rather than only going one way from loose images to one atlas.

Choosing between them

A concrete scenario

Say you are building a small game interface. You have 40 UI icons, a bitmap font, and a few hundred sprite frames. Packing all of that with one tool is tempting, but the two jobs have different constraints: font atlases need tight, predictable glyph placement, while icon sets often need to stay legible at small sizes and may need re-exporting later. A sensible split is rTexPacker for the font and sprite sheets, and rIconPacker for the icon set — especially if you expect to extract and revise individual icons during iteration.

Next step

Open the browser versions of both tools with your actual asset folder and pack one representative batch in each. Compare the resulting sheet layout and the coordinate data you get out; if the icon set needs round-tripping, that alone decides it.

How does rImageShield embed hidden messages in images and what are its use cases?

rImageShield is a small desktop utility from raylib technologies for embedding a hidden message into an image. Based on the listing, it is described as a "simple and easy-to-use image message embedder," and it is one of several lightweight, self-contained tools the studio distributes through raylib technologies.

How the embedding works in practice

The page does not publish the algorithm, so the exact method is not stated. What can be said is the general approach used by tools in this category: the message is written into the image's pixel data so the picture still looks normal, and the tool produces a new image file that carries the message. You then need the same tool (or a compatible reader) to extract it. Practical implications:

• The output is an image, not a text file. It can be shared through any channel that accepts images.
• Payload size is limited. Hidden data competes with the picture's own pixels, so short strings are realistic; long documents are not.
• Re-encoding can destroy the message. Recompressing, resizing or converting the file may strip the hidden data, so keep the original.

Use cases

What to check before relying on it

If the message must survive editing, social-media re-compression or format conversion, test the round trip first: embed, upload or re-save, then extract. If it does not survive, treat the tool as suitable for controlled sharing rather than public posting. Anyone who knows the tool exists can also try to extract the message, so this is concealment, not encryption; for genuinely sensitive content, encrypt the message before embedding.

A useful next step is to try the browser version listed on the product page, embed a short test string, and confirm you can read it back after saving and reopening the file.

Can I use rGuiStyler, rGuiIcons, and rGuiLayout together to design a complete raygui interface?

Yes. rGuiStyler, rGuiIcons and rGuiLayout are three separate browser-based editors from raylib technologies that cover different parts of a raygui interface, and they are designed to be used alongside each other. A practical division of labour looks like this:

How they fit together

Start with rGuiStyler to settle the visual language: pick or create a style so every control shares consistent colours and metrics. Use rGuiIcons to build the icon sheet your interface will reference, so icon-bearing controls draw from one coherent set. Then use rGuiLayout to place controls and produce the layout code that ties the screen together. Because all three target the same raygui ecosystem, the outputs are meant to be combined in one project rather than treated as competing alternatives.

A concrete workflow

1. Open rGuiStyler and save a style you are happy with.
2. Open rGuiIcons and export the icons your controls need.
3. Open rGuiLayout and lay out the screen, applying the style and icons.
4. Drop the generated style, icon and layout files into your raylib project and wire them into your UI code.

Each tool runs in the browser, so you can iterate quickly without building and running your game just to nudge a colour or move a button.

Trade-offs to keep in mind

The three tools are separate editors, so you manage three sets of output files and keep them in sync when the design changes. That is fine for a project with a stable UI, but if you are prototyping heavily, expect to revisit the style or icon set after the layout has settled. Also decide early whether you want a single shared style across all screens or per-screen variations; changing that later means re-exporting from rGuiStyler and re-checking every layout.

Next step

If you only need one piece, you do not have to adopt all three. A project with no custom icons can skip rGuiIcons, and a one-screen tool may not need rGuiLayout's layout export. Browse the full set at raylib technologies to see which combination matches your project, and check the official raygui documentation for how the exported files are loaded at runtime.