HeidiSQL
A lightweight client for managing MariaDB, MySQL, SQL Server, PostgreSQL, SQLite, Interbase and Firebird, written in Delphi and Lazarus/FreePascal
- 6.3k
- Pascal
- GPL-2.0
- 14 h ago
The Stability API wrapper for Delphi utilizes advanced models developed by Stability.ai to provide capabilities for seamless image, video, and 3D generation, as well as sophisticated editing and upscaling tools, tailored for creative and professional use.
Repo MaxiDonkey/DelphiStabilityAI, read from GitHub 1 min ago. MaxiDonkey has not joined Take My Repo.
MaxiDonkey/DelphiStabilityAI is a public repo on GitHub by MaxiDonkey. The Stability API wrapper for Delphi utilizes advanced models developed by Stability.ai to provide capabilities for seamless image, video, and 3D generation, as well as sophisticated editing and upscaling tools, tailored for creative and professional use. It declares the MIT license on GitHub. It is written mainly in Pascal, has 18 stars and last changed on 2025-07-05. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Stability.ai is a well-established organization in artificial intelligence, known for its models that generate images and text from descriptions. Below is a summary of the key models they have developed, presented in chronological order of release:
Image Generation Models:
Stable Diffusion (August 2022)
The first latent diffusion model, capable of generating images based on textual descriptions.
Stable Diffusion 2.0 (November 2022)
An updated version with improved image quality, support for higher resolutions, and additional features.
Stable Diffusion XL (SDXL) (April 2023)
Focused on photorealism, this version introduced improvements in image composition and face generation.
Stable Diffusion 3.0 (February 2024)
Featuring a new architecture that combines diffusion transformers and flow matching, this version enhances performance for multi-subject queries and overall image quality.
Stable Cascade (February 2024)
Built on the Würstchen architecture, this model improves accuracy and efficiency in text-to-image generation.
Stable Diffusion 3.5 (October 2024)
Includes variants such as Stable Diffusion 3.5 Large and 3.5 Medium, offering more options for diverse generation tasks with optimized efficiency.
Important
This is an unofficial library. Stability.ai does not provide any official library for Delphi.
This repository contains Delphi implementation over Stability.ai public API.
You can access the Stability.ai console to explore the available possibilities.
To obtain an API key, you need to create an account. A credit of 25 will be granted to you, and an initial key will be automatically generated. You can find this key here.
Once you have a token, you can initialize IStabilityAI interface, which is an entry point to the API.
Note
uses StabilityAI; var Stability := TStabilityAIFactory.CreateInstance(API_KEY);
Warning
To use the examples provided in this tutorial, especially to work with asynchronous methods, I recommend defining the stability interface with the widest possible scope.
So, set Stability := TStabilityAIFactory.CreateInstance(API_KEY); in the OnCreate event of your application.
Where Stability: IStabilityAI;
In the context of asynchronous methods, for a method that does not involve streaming, callbacks use the following generic record: TAsynCallBack<T> = record defined in the StabilityAI.Async.Support.pas unit. This record exposes the following properties:
TAsynCallBack<T> = record
...
Sender: TObject;
OnStart: TProc<TObject>;
OnSuccess: TProc<TObject, T>;
OnError: TProc<TObject, string>; The name of each property is self-explanatory; if needed, refer to the internal documentation for more details.
Note
In the rest of the tutorial, we will primarily use anonymous methods unless otherwise specified, as working with APIs requires it due to processing times that can sometimes be quite long.
Stable Image Ultra use the Diffusion 3.5 model. This method is distinguished by:
Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate; Stability.StableImage.Generate.ImageUltra( procedure (Params: TStableImageUltra) begin Params.AspectRatio(ratio16x9); Params.Prompt('Lighthouse on a cliff overlooking the ocean'); //A blurb of text describing what you do not wish to see in the output image. //Params.NegativePrompt('...') Params.OutputFormat(png); end, function : TAsynStableImage begin //Add a TImage on the form //Add a TMemo on the form Result.Sender := Image1; Result.OnStart := procedure (Sender: TObject) begin Memo1.Lines.Text := Memo1.Text + 'The generation has started. Please wait...' + sLineBreak; end; Result.OnSuccess := procedure (Sender: TObject; Image: TStableImage) begin var Stream := Image.GetStream; try Image.SaveToFile('lighthouse.png'); //for VCL Image1.Picture.LoadFromStream(Stream); //for FMX //Image1.Bitmap.LoadFromStream(Stream); Memo1.Lines.Text := Memo1.Text + 'Generation ended successfully' + sLineBreak; finally Stream.Free; end; end; Result.OnError := procedure (Sender: TObject; Error: String) begin Memo1.Lines.Text := Memo1.Text + Error + sLineBreak; end; end);
Detailed settings on the official documentation
To simplify the example codes provided in this tutorial, I have included two units in the source code: VCL.Stability.Tutorial and FMX.Stability.Tutorial. Depending on the option you choose to test the provided source code, you will need to instantiate either the TVCLStabilitySender or TFMXStabilitySender class in the application's OnCreate event, as follows:
Tip
//uses VCL.Stability.Tutorial;
StabilityResult := TVCLStabilitySender.Create(Memo1, Image1);or
//uses FMX.Stability.Tutorial;
StabilityResult := TFMXStabilitySender.Create(Memo1, Image1);Make sure to add a TMemo and a TImage component to your form beforehand.
It is also possible to provide a reference image to use as a starting point for generation. In this case, the strength parameter must be specified, as it determines the influence of the input image on the final output. A strength value of 0 will produce an image identical to the input, while a value of 1 indicates no influence from the initial image.
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial; StabilityResult.FileName := 'lighthouse1.png'; Stability.StableImage.Generate.ImageUltra( procedure (Params: TStableImageUltra) begin Params.AspectRatio(ratio16x9); Params.Prompt('There are many birds in the sky'); Params.Image('lighthouse.png'); Params.Strength(0.3); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Specificity:
Stable Image Core is a text-to-image generation service designed to deliver premium quality with speed. Unlike other similar tools, it requires no expertise in "prompt engineering." Users simply describe a style, scene, or character, and the tool generates an image that aligns with their description.Key Points:
Applications Inventory:
Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial; StabilityResult.FileName := 'lighthouse2.png'; Stability.StableImage.Generate.ImageCore( procedure (Params: TStableImageCore) begin Params.AspectRatio(ratio16x9); Params.Prompt('Lighthouse on a cliff overlooking the ocean'); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
You can guide the image model toward a specific style by selecting from 17 available styles.
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial; StabilityResult.FileName := 'lighthouse3.png'; Stability.StableImage.Generate.ImageCore( procedure (Params: TStableImageCore) begin Params.AspectRatio(ratio16x9); Params.Prompt('Lighthouse on a cliff overlooking the ocean'); Params.StylePreset(TStylePreset.digitalArt); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Inventory of available models
Stable Diffusion 3.5
Stable Diffusion 3.0 (Fireworks AI)
Key Points:
Turbo versions generate images faster without sacrificing quality.This mode creates an image based solely on a textual description. The prompt is the only mandatory input, but an optional aspect_ratio parameter is available to adjust the dimensions of the resulting image.
Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial; StabilityResult.FileName := 'lighthouse4.png'; Stability.StableImage.Generate.Diffusion( procedure (Params: TStableImageDiffusion) begin Params.AspectRatio(ratio16x9); Params.Prompt('Lighthouse on a cliff overlooking the ocean'); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
This method generates an image based on text input while using an existing image as the initial reference. The necessary parameters include:
prompt: the descriptive text that guides the image generation.image: the starting image that serves as the foundation for the output.strength: determines the degree to which the starting image influences the final result.mode: should be set to "image-to-image".Asynchronous Code Example
//uses StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, FMX.Stability.Tutorial; StabilityResult.FileName := 'lighthouse5.png'; Stability.StableImage.Generate.Diffusion( procedure (Params: TStableImageDiffusion) begin Params.Prompt('There are many birds in the sky'); Params.Mode(imageToImage); Params.Image('lighthouse4.png'); Params.Strength(0.6); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Note
Note: maximum request size is 10MiB.
Both modes allow the use of these optional parameters:
model: Specifies the model to utilize, such as SD3 Large, SD3 Large Turbo, or SD3 Medium.output_format: Determines the desired format of the resulting image.seed: Sets the randomness seed for the generation process.negative_prompt: Defines keywords to exclude from the generated image.cfg_scale: Adjusts the level of adherence to the prompt text during the diffusion process.Using SDXL 1.0: Use stable-diffusion-xl-1024-v1-0 as the engine_id for your request, and specify the dimensions (height and width) with one of the following combinations:
Using SD 1.6: SD 1.6 is a flexible-resolution base model designed for generating images with non-standard aspect ratios. The model is optimized for a resolution of 512 x 512 pixels. To create outputs with a resolution of 1 megapixel, we recommend using SDXL 1.0, which is available at the same price.
To use this model, set stable-diffusion-v1-6 as the engine_id in your request and ensure the height and width meet the following requirements:
Asynchronous Code Example
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, // StabilityAI.Version1.SDXL1AndSD1_6, FMX.Stability.Tutorial; StabilityResult.FileName := 'lighthouse6.png'; Stability.Version1.SDXLAndSDL.TextToImage('stable-diffusion-xl-1024-v1-0', procedure (Params: TPayload) begin Params.TextPrompts([TPrompt.New(1, 'A lighthouse on a cliff') ]); Params.CfgScale(7); Params.Height(1216); Params.Width(832); Params.Sampler(TSamplerType.K_DPMPP_2S_ANCESTRAL); Params.Samples(1); Params.Steps(30); end, function : TAsynArtifacts begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
Adjusting the Degree of Transformation
init_image_mode=IMAGE_STRENGTH with image_strength=0.35, or use init_image_mode=STEP_SCHEDULE with step_schedule_start=0.65. Both methods yield similar results, but the step_schedule mode offers additional flexibility by allowing you to specify a step_schedule_end value, giving more nuanced control if needed. For further details, refer to the specific parameter descriptions below.Asynchronous Code Example
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, StabilityAI.StableImage.Generate, // StabilityAI.Version1.SDXL1AndSD1_6, FMX.Stability.Tutorial; StabilityResult.FileName := 'lighthouse7.png'; Stability.Version1.SDXLAndSDL.ImageToImageWithPrompt('stable-diffusion-v1-6', procedure (Params: TPayloadPrompt) begin Params.TextPrompts([TPromptMultipart.New(1, 'A dog space commander') ]); Params.InitImage('lighthouse6.png'); Params.ImageStrength(0.45); Params.CfgScale(7); Params.Sampler(TSamplerType.K_DPMPP_2S_ANCESTRAL); Params.Samples(3); Params.Steps(30); end, function : TAsynArtifacts begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Tip
In our code example, the value of the Samples parameter is 3, which means that three images were generated. Only the first one is displayed. The other two were saved with indexed file names as follows: lighthouse701.png and lighthouse702.png.
Detailed settings on the official documentation
Modify specific parts of an image using a mask. The mask must match the dimensions and shape of the original image. This functionality also supports images with alpha channels.
use the métode:
ImageToImageWithMask(const Model: string; ParamProc: TProc<TPayloadMask>;
CallBacks: TFunc<TAsynArtifacts>);Tools to Enhance the Size and Resolution of Your Images
Conservative Upscaler
Creative Upscaler
Fast Upscaler
Accepts images ranging in size from 64x64 pixels up to 1 megapixel and enhances their resolution to 4K. More broadly, it can upscale images by approximately 20 to 40 times while maintaining their original details. The Conservative Upscale option focuses on preserving the image's integrity with minimal modifications and is not intended for reinterpreting the image's content.
Asynchronous Code Example
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Upscale; StabilityResult.FileName := 'Upscalelighthouse1.png'; Stability.StableImage.Upscale.Conservative( procedure (Params: TUpscaleConservative) begin Params.Image('lighthouse.png'); Params.Prompt('The light house'); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
Accepts images ranging from 64x64 pixels to a maximum of 1 megapixel, enhancing their resolution up to 4K. More broadly, it can upscale images by approximately 20 to 40 times while maintaining—and often improving—their quality. The Creative Upscale feature is particularly effective for heavily degraded images, but it is not suited for photos larger than 1 megapixel, as it applies significant reinterpretation (adjustable via the creativity scale).
Warning
This function is labeled as asynchronous by the editor, but in reality, it doesn't behave as such for a third-party application utilizing it. It operates more like a caching mechanism for a slightly delayed processing.
Asynchronous Code Example
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Upscale; Stability.StableImage.Upscale.Creative( procedure (Params: TUpscaleCreative) begin Params.Image('lighthouse.png'); Params.Prompt('The gray light house'); Params.OutputFormat(png); end, function : TAsynResults begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
We retrieve the job ID, and in the next step, we need to load the image unless the status retrieved is "in-progress." In that case, the operation should be retried.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Results, // e.g. Id ---> ea771536f066b7fd03d62384581982ecd8b54a932a6378d5809d43f6e5aa789a StabilityResult.FileName := 'Upscalelighthouse2.png'; Stability.StableImage.Results.Fetch(StabilityResult.Id, function : TAsynResults begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
The Fast Upscaler serviceincrease image resolution by 400%. Designed for speed and efficiency, it processes images in approximately one second, making it an excellent tool for improving the clarity of compressed visuals, perfect for social media posts and various other uses.
Asynchronous Code Example
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Upscale; StabilityResult.FileName := 'Upscalelighthouse3.png'; Stability.StableImage.Upscale.Fast( procedure (Params: TUpscaleFast) begin Params.Image('lighthouse.png'); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
Feature Inventory
The Erase service is designed to eliminate unwanted elements from images, such as imperfections on faces or objects on surfaces, using masking techniques.
Masks can be supplied in one of two methods:
mask parameter.Asynchronous Code Example
Note
mask is supplied, a mask will automatically be generated based on the image's alpha channel. Transparent areas will be subject to inpainting, while opaque regions will remain unchanged.mask, the mask will override the alpha channel.//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Edit; StabilityResult.FileName := 'EraseLighthouse.png'; Stability.StableImage.Edit.Erase( procedure (Params: TErase) begin Params.Image('Lighthouse.png'); Params.OutputFormat(png); end, function: TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
When a mask is provided :
Note
mask's dimensions differ from those of the image parameter, it will be automatically adjusted to match the image size. Stability.StableImage.Edit.Erase(
procedure (Params: TErase)
begin
Params.Image('Lighthouse.png');
Params.Mask('MyMask01.png');
Params.GrowMask(6);
Params.OutputFormat(png);
end,
...Detailed settings on the official documentation
Modify images intelligently by adding or replacing specific sections with new content, guided by a mask image.
This mask can be supplied in two ways:
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Edit; StabilityResult.FileName := 'InpaintLighthouse.png'; Stability.StableImage.Edit.Inpaint( procedure (Params: TInpaint) begin Params.Image('Lighthouse.png'); Params.Mask('Mask01.png'); Params.Prompt('The lighthouse is bigger'); Params.OutputFormat(png); end, function: TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
The use of the mask is identical to that described with the erase API.
Detailed settings on the official documentation
The Outpaint service allows for the seamless extension of an image by adding content in any direction to fill the surrounding space. Unlike other methods, whether automated or manual, this service is designed to reduce visible artifacts and avoid noticeable indications of image editing.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Edit; StabilityResult.FileName := 'OutpaintLighthouse.png'; Stability.StableImage.Edit.Outpaint( procedure (Params: TOutpaint) begin Params.Image('Lighthouse.png'); Params.Right(200); Params.Down(400); Params.OutputFormat(png); end, function: TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
The Search and Replace service offers a specialized form of inpainting that eliminates the need for a mask. Instead, users can specify an object to replace by describing it in plain language using a search_prompt. The service will then automatically detect and segment the specified object, seamlessly substituting it with the one described in the prompt.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Edit; StabilityResult.FileName := 'SearchReplaceLighthouse.png'; Stability.StableImage.Edit.SearchAndReplace( procedure (Params: TSearchAndReplace) begin Params.Image('Lighthouse.png'); Params.Prompt('Replace the lighthouse'); Params.SearchPrompt('Lighthouse'); Params.OutputFormat(png); end, function: TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
By utilizing the Search and Recolor service, you can change the color of a specific object in an image through a simple prompt. This specialized form of inpainting doesn't require a mask. Instead, the service automatically segments the object and applies the new colors as specified in your prompt.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Edit; StabilityResult.FileName := 'SearchRecolorLighthouse.png'; Stability.StableImage.Edit.SearchAndRecolor( procedure (Params: TSearchAndRecolor) begin Params.Image('Lighthouse.png'); Params.Prompt('The lighthouse is pink'); Params.SelectPrompt('Lighthouse'); Params.OutputFormat(png); end, function: TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
The Remove Background service precisely identifies and isolates the foreground in an image, allowing for the background to be either removed or replaced as needed.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Edit; StabilityResult.FileName := 'RemoveBackgroundLighthouse.png'; Stability.StableImage.Edit.RemoveBackground( procedure (Params: TRemoveBackground) begin Params.Image('Lighthouse.png'); Params.OutputFormat(png); end, function: TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
The Replace Background and Relight editing service enables to effortlessly change backgrounds using AI-generated images or their own uploads, while seamlessly adjusting lighting to complement the subject. This API offers an efficient image editing solution tailored for various industries, including e-commerce, real estate, photography, and creative endeavors.
Key features include:
Warning
This function is labeled as asynchronous by the editor, but in reality, it doesn't behave as such for a third-party application utilizing it. It operates more like a caching mechanism for a slightly delayed processing.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Edit; Stability.StableImage.Edit.ReplaceBackgroundAndRelight( procedure (Params: TReplaceBackgroundAndRelight) begin Params.SubjectImage('Lighthouse.png'); Params.BackgroundPrompt('cinematic lighting'); Params.OutputFormat(png); end, function: TAsynResults begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
The API returns the ID of the ongoing task, just like the Upscale Creative API. You then need to use the Fetch API, as previously mentioned.
Detailed settings on the official documentation
Tools for Creating Controlled Variations of Images and Sketches
This tool is designed for development workflows involving iterative design and brainstorming. It transforms hand-drawn sketches into polished visuals with precise adjustments. Additionally, it enables fine-tuned control over the final appearance of non-sketch images by utilizing the image's contours and edges.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Control; StabilityResult.FileName := 'Control01.png'; Stability.StableImage.Control.Sketch( procedure (Params: TSketch) begin Params.Image('lighthouse.png'); Params.ControlStrength(0.7); Params.Prompt('a medieval castle on a hill'); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
This service is designed to generate images while preserving the structure of an input image, making it particularly useful for tasks like replicating scenes or rendering characters based on predefined models.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Control; StabilityResult.FileName := 'Control02.png'; Stability.StableImage.Control.Structure( procedure (Params: TStructure) begin Params.Image('lighthouse.png'); Params.ControlStrength(0.7); Params.Prompt('a well manicured shrub in an english garden'); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
This tool analyzes the stylistic features of a given input image (control image) and applies them to generate a new image guided by a specified prompt. The output image retains the visual style of the control image while incorporating the requested content.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.StableImage.Control; StabilityResult.FileName := 'Control03.png'; Stability.StableImage.Control.Style( procedure (Params: TStyle) begin Params.Image('lighthouse.png'); Params.Prompt('a majestic portrait of a chicken'); Params.Fidelity(0.7); Params.OutputFormat(png); end, function : TAsynStableImage begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
Tools for fetching the results of your async generations.
For using, see Fetch async generation result
Stable Fast 3D generates high-quality 3D assets from a single 2D input image.
See the GLB File Format Specification for more details.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.VideoAnd3D.Stable3D; StabilityResult.FileName := 'My_Result.gltf'; Stability.VideoAnd3D.Model3D.Fast3D( procedure (Params: TStable3D) begin Params.Image('My_ImageTo3D.png'); Params.ForegroundRatio(0.85); end, function : TAsynModel3D begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
Use Stable Video Diffusion, a latent video diffusion model, to generate a short video from an initial image.
ID from the response to check the results at the image-to-video/result/{id} endpoint. Be sure not to poll this endpoint more than once every 10 seconds to avoid errors or rate-limiting issues.//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.VideoAnd3D.Video; Stability.VideoAnd3D.ImageToVideo.Generation( procedure (Params: TVideo) begin Params.Image('lighthouse1024x576.png'); end, function : TAsynJobVideo begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
At the end, we retrieve the ID (e.g. d4fb4aa8301aee0b368a41b3c0a78018dfc28f1f959a3666be2e6951408fb8e3) of the video creation task. Then, we simply retrieve the result in this way.
Detailed settings on the official documentation
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.VideoAnd3D.Video; var Id := 'd4fb4aa8301aee0b368a41b3c0a78018dfc28f1f959a3666be2e6951408fb8e3'; StabilityResult.FileName := 'lighthouse1024x576.mp4'; Stability.VideoAnd3D.ImageToVideo.Fetch(Id, function : TAsynResults begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
List the engines compatible with Version 1 REST API endpoints.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.Version1.Engines; Stability.Version1.Engines.List( function : TAsynEngines begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
Retrieve details about the account linked to the specified API key
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.Version1.User; Stability.Version1.User.AccountDetails( function : TAsynAccountDetails begin Result.Sender := StabilityResult; Result.OnStart := Start; Result.OnSuccess := Display; Result.OnError := Display; end);
Detailed settings on the official documentation
Retrieve the credit balance for the account or organization linked to the provided API key.
//uses // StabilityAI, StabilityAI.Types, StabilityAI.Common, FMX.Stability.Tutorial, // StabilityAI.Version1.User; var Balance := Stability.Version1.User.AccountBalance; try Memo1.Lines.Text := Memo1.Text + Balance.Credits.ToString + sLineBreak; finally Balance.Free; end;
Detailed settings on the official documentation
Stability.ai has announced two upcoming features:
Stable LLM 12B and Stable LLM 1.6B.Audio Stable 2.0. You can contact Stability.ai to test this model by sending a message.Pull requests are welcome. If you're planning to make a major change, please open an issue first to discuss your proposed changes.
This project is licensed under the MIT License.
MaxiDonkey/DelphiStabilityAI is a public repo on GitHub by MaxiDonkey. The Stability API wrapper for Delphi utilizes advanced models developed by Stability.ai to provide capabilities for seamless image, video, and 3D generation, as well as sophisticated editing and upscaling tools, tailored for creative and professional use.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2025-07-05. GitHub counts 0 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
A lightweight client for managing MariaDB, MySQL, SQL Server, PostgreSQL, SQLite, Interbase and Firebird, written in Delphi and Lazarus/FreePascal
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Rebuild the object in a reference image as a code-only, procedural, quality-gated, animation-ready Three.js model. Token-efficient image-to-3D.

A curated list of awesome Delphi/FreePascal/(any)Pascal frameworks, libraries, resources, and shiny things. Inspired by awesome-... stuff. Open source and freeware only!
The GroqCloud API wrapper for Delphi provides access to models from Meta, OpenAI, MistralAI and Google on Groq’s LPUs, offering chat, text generation, image analysis, audio transcription, JSON output, tool integration, and content moderation capabilities.

The Deepseek API wrapper for Delphi leverages Deepseek’s advanced models to deliver powerful capabilities for seamless and dynamic conversational interactions, including a model optimized for reasoning, and now also supports running local models through an LM Studio server.
The GenAI API wrapper for Delphi seamlessly integrates OpenAI’s latest models (gpt-5 serie), delivering robust support for agent chats/responses, text generation, vision, audio analysis, JSON configuration, web search, and asynchronous operations. Image generation with gpt-image-2. Skills and agents
The Anthropic API wrapper for Delphi leverages cutting-edge models, including Anthropic's advanced Claude series, to deliver powerful features for chat interactions, vision processing, caching, efficient batch processing, connector MCP, skills and managed agents.
Delphi wrapper for the Google Gemini API: stateless generation and agent workflows with multimodal, streaming, persistent interactions, structured outputs, vector search, batch, image/video generation, and grounding (Search/Maps).

DelphiMistralAI wrapper brings Mistral’s text-vision-audio models and agentic Conversations to Delphi, with chat, embeddings, Codestral codegen, fine-tuning, batching, moderation, async/await helpers and live request monitoring.

The Hugging Face API wrapper for Delphi leverages cutting-edge models to deliver powerful features, including object detection, music generation, text classification, sentiment analysis, image segmentation, speech-to-text transcription, and text generation.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/MaxiDonkey/DelphiStabilityAITake My Repo has not tested this on your machine. Requirements come from the project's own documentation.