Around 2002 I built an application called GeekAlarm! in Delphi 7 using the VCL. I released it as shareware on quite a few shareware sites and it saw quite a few (10k-100k) downloads. It forces you to take a break from your computer for a configurable amount of time (4 minutes every 30 minutes is the default). The description of the app is “GeekAlarm! is a unique way for you to keep track of when you should take a break while using your computer. By taking breaks you can increase your productivity, reduce eye strain, and allay fatigue. GeekAlarm! has varying degrees of break enforcement including passive, medium, and aggressive enforcement. This helpful utility is a must have for anyone that uses a computer for long periods of time.” Here is a screenshot of the original version and you can check out the GeekAlarm! website from 2006.

I have been personally running the GeekAlarm! break app on my machine since then (so maybe 18 years or so). Fast forward to a couple years ago when a Windows 10 update came out and seemed to break the app. Not sure where the source code is so I rebuilt the app in the latest version of Delphi using the FireMonkey framework. It should run on Windows 10 and I believe I have tested it on macOS. Now I am making the source code available for free over on Github to celebrate Delphi’s 25th Anniversary! If you use your computer a lot you owe it to yourself to take break and this might just help you do that!

Head over and download the full source code for GeekAlarm! built in Delphi 10.3.3 FireMonkey!

Delphi is celebrating it’s 25th Anniversary this year and I am going to outline 25 different Delphi FireMonkey demos which should run cross platform on Android, IOS, OSX, Windows, Linux, and HTML5. The main repo for the demos is over on Github and there are 100 Cross Platform Samples there (plus the same set of demos for C++ developers!). In this post we are going to highlight 25 of the most significant demos in the 100 demo list. Let’s get started!

#1 98-EmojiApp – Display and use emoji’s.

#2 99-DrawApp – Draw tools and canvas.

#3 92-MusicPlayerApp – Play music files with TMediaPlayer.

#4 95-NewsReaderApp – Consume RSS feeds.

#5 79-EmailApp – Connect to IMAP and SMTP in this email app.

#6 85-EncryptedSQLite – Create and access an encrypted SQLite database.

#7 87-InstagramFeed – Create an Instagram style image feed.

#8 94-PlaySounds – Play sounds across multiple platforms.

#9 77-Signature – Record signatures on a canvas.

#10 65-WebView – Embed a webview (web browser) in your app.

#11 67-NotesApp – Classic take notes style app.

#12 69-MakeScreenshot – Take screenshots within your app.

#13 71-HTTPPost – Send an HTTP post request.

#14 89-HTTPImage – Download an image from HTTP.

#15 90-NativeConnectivity – Check the connectivity status of your device.

#16 88-RESTToSQLite – Download from a REST service and insert it into an SQLite database.

#17 57-RunAtStartup – Run code at the start of your app (after the splash screen).

#18 56-SimpleBarChart – Create a simple bar chart in your app.

#19 49-Camera – Utilize the device camera in your app.

#20 32-SnackBar – Create a pop up message bar at the bottom of your app.

#21 31-BottomSheets – Create a pop up menu from the bottom of the app.

#22 100-AnimatedGIF – Display animated GIFs in the app.

#23 09-AsyncREST – Make an asynchronous REST request from within your app.

#24 08-FrameTabs – Break up a large app across tabs into modular frames.

#25 44-TodoList – Create a classic todo app.

Finally, head over to the Delphi 25th Anniversary site to check out some history about Delphi and what’s ahead in 2020 according to the Delphi Roadmap.

Delphi Firemonkey lets you quickly build out prototype apps very quickly and deploy them to Android, IOS, OSX, Windows, Linux, and HTML5. I put together this Emoji Easter Eggs builder app over a couple days (between 5 and 10 hours). There are a number of different Delphi 10.3.3 FireMonkey features that are used within the app including Effects, LiveBindings, custom pixel access, sharing on mobile devices, the color picker panel components, and much more. The background color gradient can be customized,  the color of the egg, the font color, the text of the message, the design on the egg, the accessory included in the lower right of the egg, and stripes available on some of the designs. The only image used within the app is the grass image. The app was mainly developed and tested on Windows 10 so there may need to be polish done for it to work at 100% on the other platforms.  Deploying the app to HTML5 would be done via Thinfinity VirtualUI or broadwayd on Linux. The Linux version is possible via FMXLinux which is available in Delphi 10.3.3 Enterprise and Architect. In addition to the Delphi features used Emojis (special graphical Unicode characters) were used for a large part of the graphics found within the Emoji Easter Egg builder app. Emoji graphics are provided by the font and platform itself so the graphics look different depending on which platform you run the app on. One the emoji egg is configured how you would like it you can take a screenshot of your configuration. The screenshots can be saved or shared depending on the platform the app is run on.

Head over and download the full source code for the Emoji Easter Egg builder app in Delphi 10.3.3 FireMonkey on Github.

It is possible to build multiple Delphi projects at the same time using MSBuild and utilize the multiple cores on most modern CPUs. I had a need to build a large number of Delphi projects (the 100 cross platform samples) and I wanted to speed this up so I build a simple utility to do so. The utility is built in Delphi 10.3.3 FireMonkey and full source code is available. The project is set to build for Windows 64bit but it would also compile to other platforms like Windows 32bit, Android, IOS, OSX, Linux, and HTML5. I noticed that Windows treats a Windows 64bit executable in TaskManager differently than a Windows 32bit executable so that’s why I went with 64bit as the default. Basically, the utility uses the TDirectory.GetFiles function to pull in all of the DPROJ and CBPROJ files recursively from a directory. Once it has the list of files it uses TTask, MSBuild, and an ExecAndWait function to run multiple compiles of the different projects at the same time. It has an option to select how many CPUs (processes) to utilize at the same time (between 1 and 9). It’s possible it could go over 9 parallel compiles but the MSBuild command line it uses wouldn’t allow a two digit number (maybe it needs to be escaped). The command line parameter might be able to be left out. This utility makes no attempt to compile a single project in parallel. The utility does include an option to clean up the project after the build as the goal is to see if there are any build errors. Build errors are loaded into a Build Log tab. The utility supports building 10.3.3 projects but support for other versions could be added.

Download the full source code for the Delphi Parallel Build utility build in Delphi 10.3.3 FireMonkey over on Github.

RAD Studio 10.4 Sydney (Delphi + C++Builder) has been released with some significant enhancements to the Firemonkey framework. 10.4 includes new Metal API support on macOS and iOS and it brings significant performance improvements. Additionally, there is a new TBufferedLayout control which will cache painting of controls contained inside of it. The product itself received over 1000 updates and fixes across the IDE, RTL, VCL, and FMX. There are a ton of updates and new features in this release which makes it difficult to catalog them all!

Items from the release that are related to cross platform Firemonkey are:

• Apple’s new launch screen storyboard requirement.
• Delphi memory management is now unified across all supported platforms – mobile, desktop, and server.
• New styled TMemo component on the Windows platform.
• FMXLinux integration for building Linux GUI applications in Enterprise and Architect.
• TWebBrowser control for iOS is now implemented using the WKWebView API
• macOS implementation of Media Player control now used AVFoundation
• Expanded HTTP and REST Client libraries with additional HTTPS features
• LiveBindings Performance and Features Enhancements

The list of fixes applied to FireMonkey 10.4 are as follows:

Head over and check out the full list of updates for Delphi 10.4 Firemonkey.

One of my all time favorite objects in Delphi is TStringList which I have been using for over 20 years. Most apps I write with Delphi usually contain at least one usage of TStringList. I rarely use arrays as TStringList usually fills that space in my toolchest (the updated array syntax makes them tempting though). TFDMemTable is becoming the new TStringList for me though as now I rarely write an app that doesn’t use a TFDMemTable at least once. Yet TStringList is still use at least once as well!

TStringList is such a versatile object because it supports easily returning it’s contents as a string and saving/loading those same contents from a file. It easily handles key value pairs, splitting strings, and holding whatever string list (as the name implies) in memory. It handles sorting and even custom sorting. It can hold a list of objects that are tied to a string name and it can even free those objects automatically with the OwnsObjects property. It can ignore duplicates like an index database table. It can even be easily searched using IndexOf or Find.

Some of my favorite TStringList methods are TStringList.SaveToFile(), TStringList.LoadFromFile(), TStringList.SaveToStream(), TStringList.LoadFromStream(), TStringList.Append(), TStringList.AddObject(), TStringList.AddStrings(), and TStringList.IndexOfName(). While the properties I use most are probably TStringList.Text, TStringList.ValueFromIndex, and TStringList.Values. You can find a full breakdown of all of these methods and properties over in the Embarcadero DocWiki for TStringList.

The details are lost but I think I even used TStringList and the legendary FastStrings library at the core of a search engine index I built at the dawn of the new millennium with ~100,000 records. The results were returned in a second or two.

TFDMemTable Data IO

Lately I’ve been using TFDMemTable because it allows me to easily LiveBind bidirectional data to visual controls. TFDMemTable is a in memory database table that is part of the FireDAC (data access library) which is available in with FireMonkey in Delphi and C++Builder. TFDMemTable supports multiple columns (not just the 2 key value columns of TStringList), indexes, searching, exporting and importing from JSON, XML, binary, and even CSV format (through TFDBatchMove). TFDMemTable can be used as a visibility state machine for buttons through livebindings (see demo).

TFDMemTable is also the recipient of JSON that is automatically imported and consumed from TRESTResponse and TRESTResponseDatasetAdapter. The JSON can be imported directly, based on a specific root field name, or even flatted so all of the fields appear as columns. TFDMemTable can even be setup as persistent so that it automatically loads and saves the data contained within it (see demo) just like as if you had used SQLite.

TFDMemTable LocalSQL And Performance

I’ve easily used over 100,000 records in a TFDMemTable on the Windows platform and it was still pretty fast. TFDMemTable can be defined as a virtual table using the TFDLocalSQL component (see demo) and then queried as if it was an SQLite table using TFDQuery and TFDTable. There are a number of performance tuning tricks for TFDMemTable available in the Embarcadero DocWiki. These tricks include turning off transaction logging, setting a record maximum, and wrapping changes in a BeginBatch EndBatch clause. When I utilize TFDMemTable with a large number of records I usually deploy the code provided in the DocWiki and see significant performance improvements.

TFDMemTable Searching

There are a number of different ways to search a TFDMemTable. Some of them require an index and some of them do not. The two main ways I’ve used are TFDMemTable.Locate() and TFDMemTable.Lookup(). The Locate() function moves the cursor of the dataset to the record if it is found while the Lookup() function does not move the cursor to the found record and instead returns the found data. Locate() and Lookup() are not unique to TFDMemTable and can be used with most FireDAC based datasets. There is a third way to search a TFDMemTable and that is through the TFDMemTable.FindKey() method. FindKey() requires an index and I’ve heard it is faster than Locate() but I haven’t used it quite as much as Locate().

As we’ve seen in the above post it is really easy to work with text based files and create structured data files like JSON, XML, and CSV in Delphi FireMonkey using both TStringList and TFDMemTable. These two objects work cross platform on Android, IOS, Macos, Windows, and Linux and can really increase developer productivity through their use. Do you use TStringList and TFDMemTable? If not what do you use instead and why?

REST Debugger Tool

The REST Debugger is a UI based app that ships with Delphi 10.4 and allows you to easily craft REST requests. You can enter various login information and parameters and then see the results parsed into a grid based on the returned JSON. The JSON can even been flattened (using the Nested setting) so that all of JSON fields are available in the grid columns. This is great but now is where the magic happens. You can click Copy Components in the REST Debugger and then directly paste them onto your form or datamodule in Delphi 10.4 Sydney (this also works with C++Builder). It will automatically create all of the TRESTRequest components plus pipe it directly into a TFDMemTable where you can utilize the data at both design time (in the IDE) and runtime after a simple TRESTRequest.Execute call.

http://docwiki.embarcadero.com/RADStudio/en/REST_Debugger_Tool

MonkeyBuilder

If you are using Delphi or C++Builder to publish to the apps stores (verses ad hoc enterprise deployment) MonkeyBuilder can be a huge time saving utility. It offers “Single-click build/deployment of iOS and Android apps”, “Generates Android *.aab 32bit/64bit app bundles”,
“Automatically uploads *.ipa files to AppStoreConnect”, “Generate all required icons from a single 1024×1024 *.png file with the Icon Generator feature”, and a bunch of other features to streamline the app deployment process. If you’ve ever wasted time getting your apps into the App Stores take a look.

https://www.monkeybuilder.io/

TFDMemTable Design Time Edit DataSet

Delphi 10.4 has a feature with TFDMemTable where you can edit the data inside a TFDMemTable at design time. This feature can really speed up development because you can edit and bake data directly into a TFDMemTable during development. It also allows you to easily investigate the contents of a TFDMemTable at design time if you are using some of the other design time features like Executing a TRESTRequest at design time. Additionally, you can use the feature to create data at design time and LiveBind it to controls. One example of this is using TFDMemTable to hold the state of buttons (Visible True and False) across tabs. Instead of writing a bunch of state change code to toggle button visibility (especially on Android and IOS devices) you just set up the states at design time with the Edit DataSet feature and you’re done.

https://flixengineering.com/archives/398

Alcinoe Component Library For Delphi

If you’re looking to do video with Delphi FireMonkey it can be overwhelming because of all of the different formats (across devices) and building a high quality video player is not for the faint of heart. The Alcinoe component library is an open source library that has already done a lot of the hard work for you to make video work great in FireMonkey on Android and IOS. On top of the video player functionality it also offers “WebRTC delphi wrapper, native ios/android TEdit, improved firemonkey controls, Firebase cloud messaging, Android/ios facebook sdk login, Json/Bson Parser, ImageMagick wrapper, MongoDb client, and much more”. It appears to be somewhat widely used as it has a high GitHub Stars count as well.

https://github.com/Zeus64/alcinoe

100 Cross Platform Samples For FireMonkey

There are over 100 cross platform samples available in one of our GitHub repos. It features a lot of simple apps but also some more complex tricks like saving a TFDMemTable to SQLite, encrypting an SQLite database, a drawing app, an emoji navigator app, a mail app, a music player, an instagram style feed interface, an RSS newsreader, a notes app, persistent TFDMemTable sample, a connectivity tester, DNS lookup, ping sample, and many many more. There are a lot of tricks used in the samples utilizing LiveBindings (like the button visibility state trick) and even control drawing buffering with TScene. The first 50 samples are also available in C++.

https://github.com/FMXExpress/Cross-Platform-Samples

https://github.com/FMXExpress/CPP-Cross-Platform-Samples

TFrameStand / TFormStand

TFrameStand and TFormStand are an easy way to break up your app into “screens” (frames and forms). The T*Stand components provide nice transitions between the screens and make it easy to wire up the screens to navigation via code. TTabControl can also be used to do something similar but visually. For large projects with a lot of frames TFrameStand and TFormStand can be a lifesaver. It keeps the memory usage of your app down by not having all of the interface controls active at the same time. I don’t directly use TFrameStand but I did use the principles behind it using the TTabControl way to easily handle over 30 screens in an enterprise app for IOS. It helped to keep IOS from closing the app due to low memory on some of the original Ipad devices.

https://github.com/andrea-magni/TFrameStand

Boyer-Moore String Search

If you are looking to get some extra speed while searching through strings using native Object Pascal code there are some Boyer-Moore implementations that can help out. Apparently, it depends on your use case whether you get extra speed out of this algorithm or not but in the one case I tested I saw a speed increase of over 10%. Ten percent may not sound like a lot until you start talking about tasks that take a long time (like an hour). I’d rather wait 54 minutes than 60 minutes for a task to complete.

Object Pascal Boyer-Moore Version On StackOverFlow

Alternate Object Pascal Boyer-Moore Version On Delphi Dabbler

For Old Versions Of Delphi There Is The Original FastStrings Library

Delphi Javascript Bridge For TWebBrowser

If you’re looking to build apps in a similar fashion to how Electron apps are put together there is an open source library called ScriptGate which can really help out there. Basically you can use the native WebView control of the device (instead of Electron’s Chromium) and have Javascript call out to Delphi for access to the file system, notifications, and high performance code. ScriptGate makes it easy to build and ship such and app with Delphi. Electron apps are known for their high inefficient memory usage and Delphi provides a solution to that through ScriptGate. Delphi FireMonkey can compile to Windows, macOS, and Linux just like Electron. Additionally, Delphi also supports Android and IOS. You can leverage the power of the Delphi RTL from within your Electron like apps.

https://bitbucket.org/freeonterminate/scriptgate/src/master/

The latest version for FireMonkey is available in Delphi 10.4.1 and C++Builder 10.4.1. There are a massive number of fixes included which touch all major supported operating systems including Android, IOS, MacOS, Windows, and Linux. On the IOS side there was an API change for THTTPClient in the form of “The NSURLConnection API was deprecated by Apple on Mac OS X 10.11 and iOS 9, but it was still used in our HTTP Client Library. 10.4.1 introduces support for the newer NSURLSession API on both platforms. This change also addresses issues with proxy support on macOS.” Additional enhancements were made to the new TMemo on Windows and the new TMemo was also now upgraded on MacOS. Much of the “focus is on TMemo IME mode for Korean, Japanese, and Chinese (among other languages) but there are also general improvements in performance, stability, scrolling behavior, mouse selection, copy and paste, and more.” Lastly, these enhancements were added for FireMonkey:

• The Storyboard Launch Screen has added support for icon sizes required by Apple for iOS.
• Improved permissions management for iOS Push notifications
• TListView OnItemClick fires even if already selected
• Fixed an issue with inconsistent values for TMediaPlayer.Duration on Android
• iOS WebBrowser issue with external links
• TStringGrid OnCellDblClick event
• TListView Checkmark Accessory disappearing

Here is a list of bug fixes as they relate to FireMonkey and cross platform development with Delphi 10.4.1:

Head over and check out the full list of fixes and updates available in FireMonkey 10.4.1.

The post Significant Update Available For Delphi FireMonkey 10.4.1 On Android, IOS, OSX, Windows, And Linux first appeared on Delphi XE8 10 Seattle Berlin Tokyo Rio Sydney Firemonkey, Delphi Android, Delphi IOS.

Over on Github there is a sample email client which uses IMAP and SMTP for receiving and sending mail. It has basic features like viewing, composing, and sending mail. Full source code is available and it should run on Android, IOS, OSX, Windows, and Linux. It uses the Indy library which ships with Delphi 10.4.1 for IMAP and SMTP. The Indy library for email is quite extensive but only the most basic features were added into the app because it is a sample. Indy is also available for use from C++ from within C++Builder.

The email app is a sample app which is part of the 100 cross platform samples set. It was mainly tested on Windows so there may need to be small tweaks made for it to run smoothly on the other platform. It uses TFDMemTable to store settings and the mail itself. It only took 585 lines of code to build the entire app (obviously the libraries it uses are a lot more code).

Here is some sample code which shows how simple it is to send an SMTP message via Indy:

var
LMessage: TIdMessage;
LAddress: TIdEmailAddressItem;
begin
  // send
  LMessage := TIdMessage.Create(nil);
  try
    LAddress := LMessage.Recipients.Add;
    //LAddress.Name := '';
    LAddress.Address := SendToEdit.Text;
    //LMessage.BccList.Add.Address := '';
    //LMessage.From.Name := '';
    LMessage.From.Address := SendFromEdit.Text;
    LMessage.Body.Text := SendMemo.Lines.Text;
    LMessage.Subject := SendSubjectEdit.Text;

    IdSMTP1.Host := SettingsFDMemTable.FieldByName('SmtpHost').AsString;
    IdSMTP1.Port := SettingsFDMemTable.FieldByName('SmtpPort').AsInteger;
    IdSMTP1.Username := SettingsFDMemTable.FieldByName('SmtpUser').AsString;
    IdSMTP1.Password := SettingsFDMemTable.FieldByName('SmtpPass').AsString;
    case SmtpSSLCB.ItemIndex of
      -1,0: IdSMTP1.UseTLS := utNoTLSSupport;
      1: IdSMTP1.UseTLS := utUseExplicitTLS;
      2: IdSMTP1.UseTLS := utUseImplicitTLS;
      3: IdSMTP1.UseTLS := utUseRequireTLS;
    end;
    IdSMTP1.Connect;
    try
      IdSMTP1.Send(LMessage);
    finally
      IdSMTP1.Disconnect
    end;
  finally
    LMessage.Free
  end;

Head over and download the full source code for the app on Github for Delphi 10.4.1 FireMonkey on Android and IOS.

The post Powerful Cross Platform Email App Sample In Delphi 10.4.1 FireMonkey For Android And IOS first appeared on Delphi XE8 10 Seattle Berlin Tokyo Rio Sydney Firemonkey, Delphi Android, Delphi IOS.

The Gorilla3D Framework for FireMonkey has been updated with significant new features and support for Android64 (in addition to Windows). Gorilla3D is a powerful, easy to use, and modern 3D framework for Delphi and C++ Builder FireMonkey. IOS and OSX support are not mentioned. This is a commercial product but source code is available. It’s nice to see some significant improvement in 3D solutions for FireMonkey with this solution. The main new features in this release are listed as:

• 10.4.1 support incl. ANDROID64 support
• WBOIT Rendering for order-independent rendering (no sorting of elements anymore)
• TGorillaPhysicsCharacterController
• TGorillaFirstPersonController, TGorillaThirdPersonController
• TGorillaAnimationController
• TGorillaTriggerPointsManager
• TGorillaAudioManagerController
• Multiple sources in billboarding
• Texture format support for 2D, 3D and CubeMap textures
• Individual blend controlling in your render pass
• New primitives: torus, cone, tube, capsule
• New 3D formats: gltf, babylon, sketchfab
• more materials inherited from TGorillaDefaultMaterialSource
• New Materials: TGorillaSharedMaterialSource, TGorillaSharedAtlasMaterialSource
• New capsule physics collider
• Bugfixed terrain/mesh collider
• Skybox is now rendered from cube map
• 100+ bugfixes

Key-Features

Here a list of the currently implemented features inside the framework.

•   Skin-, Skeleton- und Vertexanimations for 3D Meshes (Key-Animations)
•   Integrated and fast Q3 Physics Engine (with collision detection)
•   Materials: textures, normal-mapping, vertex-color, phong-, blinn-, lambert-materials, water and reflection, layered materials, splatmaps, terrain-material, atlas-texturing
•   Loading complex multi-mesh models with UV-textures
•   Logical model management (independent from FireMonkey tree), to manage a large amount of meshes and to instanciate separatly
•   Flexible particle-system with influencer-classes (up to 100K particle at runtime)
•   Shadow-Mapping and Variance-Shadow-Mapping (experimental)
•   Frustum Culling
•   Fog rendering
•   Cubemap-Textures and Texture3D support
•   Mesh-Multiplication with multiple sources for grass and trees
•   Order-Independent Rendering (WBOIT) for better transparency effects
•   Multipass-Rendering
•   Bokeh/Depth-Of-Field
•   Skybox-support
•   Terrain rendering: from height-maps and procedural algorithms (Diamond-Square, Perlin-Noise, …)
•   SphereTerrain variation of default terrain component
•   CVLOD Terrain for large terrain with chunks and auto-focus level of detail detection
•   New Point3D-, Quaternion-, Transformationsmatrix- und VertexKey-Animationen
•   FMOD AudioManager for professional audio playback
•   AssetsManager with packaging system
•   Flexible DialogueSystem: load, save and edit at runtime
•   Flexible InventorySystem: load, save and edit at runtime
•   Flexible SkillSystem: load, save and edit at runtime
•   InputController for easy usage of hotkeys and input sequence detection
•   FirstPerson- and ThirdPerson character controllers
•   PhysicsCharacterController combines InputController, CharacterController (FirstPerson/ThirdPerson), AnimationController, AudioManagerController, TriggerPoints controlling and Q3 Physics to build a modern 3D game with physics collision.
•   GorillaScript for easy scripting implementation and using FMX and Gorilla3D at runtime
•   Fast 3D model loading
•   Compatible with existing FireMonkey components
•   Platform-independent: WIN32, WIN64, ANDROID, ANDROID64
•   Formate: G3D, X3D, X3DZ, X3DVZ, OBJ, STL, DAE, FBX, glTF, Babylon, Sketchfab
•   C++ support by header and lib files

Head over and check out all of the info about Gorilla3D for Delphi FireMonkey!

The post Powerful Commercial Gorilla3D Framework Upgraded For Delphi FireMonkey On Windows And Android first appeared on Delphi XE8 10 Seattle Berlin Tokyo Rio Sydney Firemonkey, Delphi Android, Delphi IOS.

Embarcadero is having a Delphi online event in November 2020 featuring two FireMonkey sessions. The first session is around a new FireMonkey book called Delphi GUI Programming with FireMonkey by Andrea Magni. The second session called FireMonkey and Multi-Device Panel is a roundtable featuring Marco Cantù, Ray Konopka, Kelver Merlotti, David Millington and Olaf Monien. The sessions will be available after the date for on demand viewing. There are also a lot of other Delphi sessions available at Delphicon 2020.

• Delphicon 2020 Keynote
• Delphi at the University: Insights for Students and Teachers
• High Performance Delphi
• Functional Programming With Delphi
• Delphi Product Management & Architect Panel
  Real-world CodeSite Logging Techniques
• Windows VCL Panel
  Leveraging High DPI in VCL Applications
• FireDAC Database Access Panel
• Code Faster in Delphi
• Upgrade and Migration Panel
  Delphi GUI Programming with FireMonkey
• Powering the Web with Delphi
• Introduction to Spring4D – Taking Delphi Development to the Next Level
• FireMonkey and Multi-Device Panel
• Delphi in Education Panel

Head over and watch the new Delphicon 2002 FireMonkey sessions from Embarcadero!

The post DelphiCon 2020 FireMonkey Sessions Available Starting November 19 first appeared on Delphi XE8 10 Seattle Berlin Tokyo Rio Sydney Firemonkey, Delphi Android, Delphi IOS.

The latest version for FireMonkey is available in Delphi 10.4.2 and C++Builder 10.4.2. There are a massive number of fixes included which touch all major supported operating systems including Android, IOS, MacOS, Windows, and Linux. It features updated support for iOS 14 in the App Store and ad-hoc enterprise deployment. Additionally, it features support for macOS 11 Big Sur on Intel and 64-bit App Store and enterprise deployment. Finally, it supports Android 11 and App Bundle format improvements. You can check out the full release notes here. Lastly, these enhancements were added for FireMonkey:

• MSIX support for Windows Store
• Enhanced Code Insight using the LSP technology for Delphi and C++
• Many Improved IDE features and a new IDE style
• A silent installer
• Delphi RTL and C++ RTL improvements, including Dinkumware STL
• Quality improvements for Delphi compiler speed, the C++ toolchain, FMX, database access, HTTP, and REST client libraries, Parallel Programming Library, SOAP, the Migration Tool, and more.

Here is a list of bug fixes as they relate to FireMonkey and cross platform development with Delphi 10.4.2:

Head over and check out the full fix list for RAD Studio 10.4.2 FireMonkey for Android, iOS, macOS, Windows, and Linux.

As developers, we are always looking for new and interesting ways to challenge ourselves and create something new. In this blog post, we will explore how to create AI text-to-image prompts using a cross-platform application built using Delphi 11 FireMonkey. These prompts will be used to generate images using Stable Diffusion. Stay tuned as we walk you through the process of creating these prompts and show you some examples!

What is Stable Diffusion?

StableDiffusion is an open source software development platform that enables generative AI. It allows developers to create and train neural networks without the need for extensive coding knowledge. The platform also provides a library of pre-trained models that can be used to generate new data sets or improve the accuracy of existing ones. In addition, StableDiffusion offers a number of tools for visualizing and debugging neural networks. As a result, it is an essential tool for anyone interested in developing generative AI applications.

What is a generative AI prompt generator?

A prompt generator is a type of AI that is designed to generate creative prompts for writers, artists, and others. The goal of a prompt generator is to help spark the creative process by providing ideas and inspiration. Prompt generators can be used for a wide range of purposes, from generating ideas for new stories and characters to helping artists come up with new painting or sculpture concepts. There are many different types of prompt generators, but they all share the same basic goal: to help you tap into your creativity and come up with new ideas. Whether you’re a writer who is struggling to find new story ideas, an artist who wants to explore new mediums, or simply someone who is looking for a fun way to spark their creativity, a prompt generator can be a helpful tool.

What is the Stable Diffusion Text To Image Prompts generator?

The Prompts generator is a tool that allows you to select from a number of different image art formats, perspectives, styles, variations, and more to build the ultimate prompt for generative AI text to images using Stable Diffusion, MidJourney, or DALL-E. The Prompts generator comes with a built in Generate Image feature which uses the StableDiffusionApi.com REST API to use the prompt you’ve built to generate an image.

What are some sample fan art for Delphi prompts created with the app?

• Glass Paint of Greek Temple, Tilted Frame, in the style of Gothic, Metallic, Trending On Artstation
• Action Photography of Greek Temple, Shallow Depth Of Field, in the style of Cyberpunk, Ethereal, 70Mm
• Architectural Photography From Magazine of Greek Temple, 1/1000 Sec Shutter, in the style of Art Deco, Utopian, Unreal Engine
• Glitter of Greek Temple, Aerial View, in the style of The Movie Matrix, Muted, Well Preserved
• Stained Glass Window of Greek Temple, Long Shot, in the style of Fauvism, Broken, Vivid

What does a Stable Diffusion generated image of a Greek Temple look like?

What does the Stable Diffusion Text To Image Prompts generator look like?

Here is a screenshot from the Prompts generator running on Windows. It is cross-platform so it also runs on Android, iOS, macOS, and Linux with a single codebase and single UI.

Ready to download the Prompts generator?

The full source code for the Stable Diffusion Text To Speed Prompts generator is available over on Github. You need Delphi 11.1 or higher to be able to compile it and you will also need an API key from StableDiffusionApi.com to generate images from within the app. There is also a prompt generator available for the Delphi VCL framework.

Head over to Github to download the full source code for the Stable Diffusion Text To Speed Prompts generator.

In an era where artificial intelligence (AI) has emerged as a game-changer in various fields, it comes as no surprise that songwriting isn’t an exception. Machine learning models have now evolved to such a point where they can assist artists in creating lyrics, offering a blend of AI and human creativity that was once unimaginable. Today, I’ll introduce you to Song Writer AI, its capabilities, and how it could potentially revolutionize the music industry.

Introduction to Song Writer AI

Songwriting AI refers to advanced machine learning models designed to help in creating song lyrics. These models, like OpenAI’s GPT-4 and Vicuna-13b, learn from vast amounts of text data and generate text that is contextually relevant and remarkably human-like. They are capable of understanding prompt and context, making them incredibly useful for tasks such as songwriting.

Which AI Models can do Songwriting?

A variety of AI models can produce songwriting. These include:

1. GPT-4: An advanced version of the Generative Pretrained Transformer developed by OpenAI. The model is known for its ability to generate high-quality, coherent text.
2. Vicuna-13b: A powerful language model designed for a range of applications, including songwriting.
3. GPT-3.5-Turbo: Another OpenAI model, GPT-3.5-Turbo is a slightly smaller and more cost-effective model than GPT-4, but still capable of generating high-quality text.

How Does Song Writer AI Work?

To get started, you’ll need to sign up for an API key from OpenAI or Replicate.com. Once you have an API key, you can integrate it into a software client built with a framework such as Delphi using the FireMonkey framework, which supports multiple platforms like Windows, macOS, and Linux with a single codebase and UI. It is an open source project on Github.

The client features a REST integration with the services mentioned, allowing users to access the AI’s functionality directly within the client. The user provides a prompt (a line, a theme, or even a mood), and the AI models generate song lyrics based on this input, offering a new level of creativity and inspiration.

What is The Future of Songwriting with AI?

AI’s role in songwriting is not to replace human creativity but to augment it. It can help generate ideas, overcome writer’s block, and inspire new directions for songs. Moreover, its ability to learn and improve over time can lead to even more impressive results in the future.

However, it’s essential to understand that while these models can generate lyrics, the human element in music—the raw emotion, personal experiences, and unique perspective—is something that AI cannot replicate. Therefore, AI in songwriting serves as a tool, a creative partner, rather than a replacement for human songwriters.

In conclusion, songwriting AI is a fascinating field, poised to push the boundaries of creativity in the music industry. As AI continues to evolve,

we can only imagine how much further it will enhance the songwriting process.

What are the Applications in the Music Industry?

Beyond just aiding individual songwriters, AI has the potential to significantly influence the broader music industry. Here are a few potential applications:

1. Music Education: Songwriting AI can serve as an incredible tool for teaching and learning music. It can provide students with a wide array of lyrics and song structures to study and learn from.
2. Music Production: Producers and music directors can use AI to quickly generate lyrics for various moods and genres, significantly reducing the time and effort required in the songwriting process.
3. Music Therapy: AI-generated music and lyrics can be used in therapeutic settings to help people express their emotions and promote mental well-being.
4. Inclusive Songwriting: AI can be programmed to generate songs in multiple languages and cultural contexts, promoting inclusivity in music.

What are the Challenges and Ethical Considerations?

Like any technology, Song Writer AI also presents its share of challenges and ethical considerations. For instance, questions about intellectual property rights can arise when AI-generated songs become commercial hits. Determining who owns the copyright—the AI, the person who inputted the prompt, or the entity that owns the AI—will be a complex issue to navigate.

Moreover, there’s the question of originality and authenticity. As AI becomes more prevalent, distinguishing between human-made and AI-generated songs may become increasingly difficult. This could potentially dilute the value of human creativity in the music industry.

Ready to get started writing your first song lyrics with AI?

Song Writer AI presents a thrilling blend of technology and creativity, offering a myriad of possibilities for the future of music. While it’s not without its challenges, its potential to revolutionize the songwriting process and the music industry as a whole is undeniable.

As we continue to explore the possibilities and navigate the complexities, one thing is clear: Song Writer AI is not just the future—it’s the present. It’s a new tool in our creative arsenal, ready to inspire and be inspired. After all, isn’t that what music is all about?

Check out the full Song Writer AI project on Github. Access the source and download the Windows client.

As a writer, blogger, and marketer, you know the importance of quality content to attract and engage audiences. But you also know how time-consuming and demanding content creation can be, especially if you need to come up with fresh and relevant ideas on a regular basis. What if you could automate and streamline the writing process using cutting-edge software that leverages advanced natural language processing and machine learning models? That’s where AutoBlogAI comes in.

What is AutoBlogAI?

AutoBlogAI is a cross-platform software tool built with Delphi FireMonkey, a popular rapid application development environment, to enable automatic article writing. With AutoBlogAI, you can use the power of latest language models such as GPT-3.5-Turbo, GPT-4, and Vicuna, to generate high-quality and customized articles that match your preferences and specifications. AutoBlogAI features APIs from OpenAI and Replicate.com that allow it to learn from and adapt to diverse datasets and contexts.

What are the differences between OpenAI LLMs and open source LLMs like Vicuna-13b?

GPT-4 and GPT-3.5-turbo, both creations of OpenAI, have undeniably revolutionized the AI landscape with their robust capabilities in understanding and generating language. However, their accessibility is somewhat limited as they are primarily available through OpenAI’s proprietary API. This mode of deployment restricts their use to internet-enabled contexts and may present challenges for applications that require local, offline utilization or when data privacy is a top concern.

Contrarily, Vicuna 13b stands out due to its enhanced versatility in deployment options. One way of running Vicuna-13b is via Replicate.com’s API, but it also offers the unique advantage of being able to run locally, a feature that significantly broadens its utility across various scenarios. This element of flexibility gives it an edge over GPT-4 and GPT-3.5-turbo, particularly in instances where data security is paramount, or when offline operation is required. Additionally, Vicuna 13b has been trained using responses from OpenAI’s GPT series, contributing to its impressive language understanding and generation capabilities. While it might not yet match the intricate sophistication of GPT-4 or the turbo version of GPT-3 in all aspects, its combined strengths of near-par language proficiency and versatile accessibility make it a compelling choice in the world of AI language models.

How does AutoBlogAI work?

AutoBlogAI uses a combination of deep learning, language model fine-tuning, and text generation algorithms to produce human-like articles that capture the tone, style, and essence of your desired niche. You can provide specific prompts or topics to AutoBlogAI, as well as adjustable parameters such as length, coherence, creativity, and fluency. AutoBlogAI also supports multiple languages and formats, from news articles to blog posts to product reviews.

What are LLMs and generative AI?

LLM stands for Large Language Models, which are advanced deep learning models trained on massive amounts of text data to learn patterns and structures of natural language. LLMs are capable of generating coherent and fluent text that mimics human-written text. Generative AI refers to the class of AI algorithms that can create new content based on existing data or conditions, using probabilistic or rule-based approaches. AutoBlogAI is a prime example of generative AI, powered by LLM and other AI techniques.

What is Delphi FireMonkey?

Delphi FireMonkey is an Object Pascal-based framework that allows developers to create visually stunning and cross-platform applications for Windows, macOS, iOS, and Android. Delphi FireMonkey offers an easy-to-use and flexible interface that enables developers to design, code, debug, and deploy applications with high performance and scalability. Delphi FireMonkey is also compatible with many popular libraries and APIs, including those used by AutoBlogAI.

What are the benefits of AutoBlogAI?

AutoBlogAI offers several advantages over traditional article writing, such as:

1. Time-saving and efficiency: AutoBlogAI can generate articles in minutes or even seconds, saving you hours or days of writing and editing. AutoBlogAI can also optimize your keyword strategy, enhance your search engine optimization (SEO) rankings, and expand your content reach.
2. Quality and customization: AutoBlogAI can produce articles that are both informative and engaging, tailored to your target audience and goals. AutoBlogAI can also generate multiple versions of the same article, enabling you to test and compare different styles and options.
3. Innovation and differentiation: AutoBlogAI can help you stand out from the competition by offering unique and diverse content that captures the latest trends and insights. AutoBlogAI can also provide fresh perspectives and ideas that you may not have thought of.

What is the future of generative AI?

AI is a fast-evolving technology that has the potential to transform the content creation industry. As AI models and frameworks improve and expand, AI may become more accurate, versatile, and user-friendly. AI may also address some of the ethical and cultural challenges of content creation, such as representation, diversity, and authenticity.

In conclusion, AutoBlogAI is a powerful tool that enables you to unleash your creativity and productivity as a writer, blogger, and marketer. By harnessing the power of Delphi, LLMs, and generative AI, AutoBlogAI frees you from mundane and repetitive tasks, and empowers you with quality and relevance. Whether you are a freelancer, a business owner, or a content strategist, AutoBlogAI can help you achieve your goals and expand your impact. Try AutoBlogAI today and see the results for yourself!

Head over and download the AutoBlogAI binary for Windows or get the source code.

The realm of generative AI continues to push boundaries, and Flux 1.1 Pro emerges as a standout generative AI image generation model. To bridge the gap between this powerful model and end-users, we’ve developed a desktop GUI client that wraps around the Replicate API, providing seamless access to Flux 1.1 Pro’s capabilities. Built using Delphi FireMonkey for Python, this application not only showcases the generative prowess of Flux 1.1 Pro but also demonstrates the cross-platform versatility of FireMonkey.

This project serves as a practical example of how developers can leverage FireMonkey to create AI applications with ease.

What are the Key Features?

• Generative AI Integration: Direct access to the Flux 1.1 Pro image generation model via the Replicate API.
• Cross-Platform Compatibility: Thanks to FireMonkey, the GUI client runs smoothly on Windows, macOS, Linux, and even mobile platforms.
• Delphi FireMonkey for Python: Combines the robustness of Delphi Object Pascal with the simplicity of Python, offering a flexible development environment.
• User-Friendly Interface: An intuitive GUI that makes generative AI accessible to users without deep technical expertise.
• Open-Source and Customizable: The code is open for contributions, allowing developers to tweak and enhance the application as needed.

How can I Harnessing FireMonkey for AI Applications?

FireMonkey (FMX) is renowned for its ability to create cross-platform applications using a single codebase. By integrating FireMonkey with Python, developers can enjoy the best of both worlds—Delphi’s powerful UI framework and Python’s simplicity and extensive libraries.

Our desktop GUI client demonstrates how FireMonkey for Python can be utilized to build sophisticated AI applications:

• Seamless API Integration: Utilizing the Replicate API, the client communicates with the Flux 1.1 Pro model to generate images based on user input.
• Rich UI Components: FireMonkey provides a wealth of UI elements that enhance user experience and streamline application development.
• Efficient Development Workflow: The combination of Delphi and Python accelerates the development process, reducing time-to-market.

#image_title

How can I Getting Started with the Flux 1.1 Pro GUI Client?

To experience the generative capabilities of Flux 1.1 Pro through our GUI client:

1. Clone the Repository: Navigate to our GitHub page and clone the project to your local machine.
2. Install Dependencies:
   • Ensure you have Python installed.
   • Install FireMonkey for Python and any other required libraries as specified in the repository.
3. Acquire a Replicate API Key:
   • Sign up on the Replicate platform to obtain an API key.
   • This key will allow the application to access the Flux 1.1 Pro model.
   • Add the key into the source code.
4. Run the Application:
   • Launch the GUI client.
   • Enter your Replicate API key when prompted.
   • Begin generating images using Flux 1.1 Pro’s generative AI capabilities.

What About The Power of Generative AI with Flux 1.1 Pro?

Flux 1.1 Pro is a cutting-edge image generation model that leverages advanced algorithms to create stunning visuals based on user prompts. By integrating this model into a desktop application:

• Accessibility: Users can interact with generative AI without needing to write code or understand complex algorithms.
• Creativity Unleashed: Artists, designers, and hobbyists can experiment with image generation to inspire new ideas and creations.
• Educational Value: Developers and students can learn about AI integration and application development in a hands-on manner.

Is FireMonkey Cross-Platform?

One of the standout features of our GUI client is its cross-platform nature:

• Single Codebase Deployment: Write once, deploy everywhere—FireMonkey eliminates the need to write platform-specific code.
• Delphi and Python Synergy: Whether you prefer Delphi’s Object Pascal or Python, FireMonkey accommodates both, providing flexibility in development.
• Consistent User Experience: Users enjoy a uniform interface and performance across different operating systems.

What are you waiting for? Unlock the power of Flux 1.1 Pro and FireMonkey!

The Flux 1.1 Pro Desktop GUI Client exemplifies how generative AI models can be made accessible through thoughtful application design. By leveraging FireMonkey for Python, we’ve created a cross-platform tool that not only unlocks the potential of Flux 1.1 Pro but also serves as a testament to the capabilities of FireMonkey in AI application development.

Whether you’re a developer eager to explore the intersection of AI and cross-platform development, or a user excited to dive into generative image creation, our GUI client offers a gateway to innovation and creativity.

Download the Flux 1.1 Pro Desktop GUI project.

In the world of digital imagery, achieving the perfect balance between resolution and quality is a constant challenge. Whether you’re working on a personal project or a professional portfolio, having access to tools that enhance the clarity and detail of your images is critical. The AI Image Upscaler, built with DelphiFMX for Python, is a desktop application that uses cutting-edge artificial intelligence to upscale images while preserving—and even enhancing—their quality. Let’s explore how this tool can revolutionize your image processing workflow.

What Makes the AI Image Upscaler Unique?

The AI Image Upscaler stands out for several reasons. First, it’s a cross-platform desktop application that works seamlessly on Windows, macOS, and Linux, giving users flexibility regardless of their operating system. As a locally hosted solution, it allows you to process images securely on your machine without relying on cloud services, ensuring privacy and faster results.

The app is built with DelphiFMX, a powerful framework that allows Python developers to build native desktop applications. This means you get the performance and responsive design typical of native apps, with the added benefit of Python’s extensive libraries and simplicity. DelphiFMX enables this app to run efficiently on multiple platforms, offering a uniform and user-friendly experience.

#image_title

How Does FireMonkey (FMX) Enhance This App?

The FireMonkey (FMX) framework, used in DelphiFMX, plays a pivotal role in the development of the AI Image Upscaler. FireMonkey is a cross-platform UI framework that supports Windows, macOS, Linux, iOS, and Android. Its flexibility allows developers to build a single codebase that works seamlessly across all these platforms, significantly reducing development time and effort.

FireMonkey is known for its powerful graphics rendering capabilities, making it a natural fit for applications that handle images. It supports GPU-accelerated graphics, enabling smooth handling of high-resolution images, animations, and 3D objects. Additionally, it allows the creation of highly customized, visually appealing user interfaces, ensuring that the app not only functions well but also provides a great user experience.

For Python developers using DelphiFMX, FireMonkey opens the door to creating native desktop applications without the overhead of managing multiple platform-specific codebases. This makes the AI Image Upscaler an optimal solution for cross-platform image processing, offering a high level of performance and graphical fidelity.

How Does AI Enhance Image Quality?

Artificial intelligence is the core technology behind the AI Image Upscaler. Traditional methods of upscaling images, like bilinear or bicubic interpolation, can result in pixelation or blurry images because they merely stretch the existing pixels. However, AI-based upscaling uses deep learning algorithms to analyze the image and add new details that weren’t present in the original.

The AI model behind this tool is designed to recognize patterns in textures, edges, and shapes, allowing it to intelligently enhance the image without introducing noise or distortion. This means that your upscaled images retain sharpness, detail, and color accuracy, making them look like they were captured in a higher resolution from the start.

Whether you’re working with photos, digital art, or low-resolution graphics, this tool can add layers of detail that transform the visual quality of your work.

How Does the Clarity Upscaler Model Enhance Image Quality?

The Clarity Upscaler model, hosted on Replicate.com, applies advanced machine learning techniques to improve image resolution and visual fidelity. This model uses sophisticated diffusion-based upscaling, LoRA techniques, and customizable settings for optimal performance. Let’s break down its key features and how they contribute to upscaling.

What Role Does the Seed Play in Image Upscaling?

In this case, the seed is set to 1337, which helps ensure reproducibility. The seed controls the randomness involved in generating results during upscaling, so using the same seed guarantees the same visual outcome. When using machine learning models like this, it’s crucial for testing different configurations or reapplying the same model to yield consistent results.

What Impact Does the Prompt Have on the Upscaling Process?

The prompt used in this case—"masterpiece, best quality, highres, <lora:more_details:0.5> <lora:SDXLrender_v2.0:1>"—helps guide the model in terms of what qualities to emphasize. It includes references to LoRA (Low-Rank Adaptation) models, such as more_details and SDXLrender_v2.0, which fine-tune the output to add intricate detail and improve rendering quality. The prompt essentially tells the model to prioritize high-resolution, masterpiece-like qualities.

What Happens When Handfix Is Disabled?

The handfix option is disabled here, meaning the model doesn’t specifically adjust for hand-related artifacts or errors. This feature is generally used when working with images of people to ensure accurate rendering of hands, a common area of difficulty for AI models.

How Does Pattern Mode Affect the Upscaling?

In this configuration, pattern mode is set to false, meaning the model doesn’t prioritize maintaining patterns or textures in specific repetitive ways. This is useful when working with images that need to retain certain uniform textures, but disabling it might result in a more natural and fluid upscale without rigid pattern preservation.

How Does the Model Deal with Sharpness?

Sharpness control is set to 0, indicating that no additional sharpening filters are applied. This ensures that the model relies solely on its native processes for enhancing clarity rather than artificially sharpening the image, which could lead to overly harsh or unnatural edges.

What Is the Significance of Using the juggernaut_reborn.safetensors Model?

The sd_model field points to the model file juggernaut_reborn.safetensors [338b85bc4f]. This specific checkpoint is likely optimized for image quality and high-fidelity upscaling, providing a balance between detail enhancement and naturalness in the output. Safetensors format ensures that the model is memory-efficient and optimized for performance.

How Does the DPM++ 3M SDE Karras Scheduler Affect the Upscaling Process?

The scheduler chosen, DPM++ 3M SDE Karras, is a specific type of noise scheduler used in diffusion models. This setting impacts the smoothness and fidelity of the image generation process, helping the model traverse from noise to the final upscaled image in a controlled manner. Karras schedulers are known for balancing speed and quality in diffusion processes.

What Does Creativity Control at 0.35 Do?

The creativity parameter, set to 0.35, fine-tunes the balance between adhering to the original image structure and introducing creative freedom in the upscaling process. A lower value, like 0.35, means the model sticks closer to the original image without making too many artistic changes or enhancements, ensuring that the upscaling looks natural and faithful to the source.

What Is the Purpose of the Resemblance Setting at 0.6?

The resemblance parameter, set to 0.6, defines how closely the upscaled image should match the original. A value of 0.6 suggests that the model is allowed some freedom in introducing changes to improve quality while still maintaining a significant resemblance to the original image.

What Does the Scale Factor of 2 Achieve?

The scale_factor is set to 2, meaning the model doubles the resolution of the input image. This is a typical use case for upscaling models where the goal is to increase the resolution while preserving or enhancing visual details.

How Does Tiling Work in This Model?

The tiling_width and tiling_height are set to 112 and 144, respectively. This indicates that the model breaks the image into tiles of these dimensions during processing. Tiling is a useful technique for handling large images by processing smaller chunks and reassembling them, thus managing memory and computational load more effectively.

What Does the Negative Prompt Control?

The negative_prompt parameter, (worst quality, low quality, normal quality:2) JuggernautNegative-neg, directs the model to avoid specific undesirable outcomes, such as low-quality or average results. This negative prompt ensures the model steers clear of creating an image with poor visual fidelity by explicitly telling it what not to focus on.

How Does the Number of Inference Steps Affect the Result?

With num_inference_steps set to 18, the model goes through 18 steps during the diffusion process to upscale the image. Fewer steps typically result in faster processing but lower quality, while more steps offer finer detail at the cost of speed. Here, 18 steps suggest a balance between quality and performance.

What Is the Purpose of Downscaling Resolution?

The downscaling_resolution is set to 768, meaning the model downsamples the image to this resolution at some stage in the process before applying enhancements. This technique helps manage larger images, allowing the model to focus on detail before resizing for the final upscale.

What Are the Key Features of the AI Image Upscaler?

• AI-Powered Image Enhancement: The tool uses sophisticated machine learning models to upscale images, adding realistic details and textures that traditional upscaling methods can’t match.
• DelphiFMX-Powered UI: Built with DelphiFMX for Python, the app offers a smooth, intuitive desktop experience on Windows, macOS, and Linux. It provides a native application feel, thanks to FireMonkey’s high-performance graphics capabilities.
• Cross-Platform Compatibility: The application runs seamlessly on all major desktop platforms, allowing users to work in their preferred environment.
• Responsive Background Processing: The upscaling process runs in the background, allowing users to continue interacting with the app without any delays or interruptions.

How Can You Get Started with the AI Image Upscaler?

Getting started with the AI Image Upscaler is as simple as cloning the GitHub repository. The app is built with an easy-to-use graphical interface, so you don’t need to be a developer to start enhancing your images. Just load your image, run the upscaler, and let the AI do the heavy lifting.

The application provides real-time feedback via a status bar, showing you the progress of the upscaling process, and ensures that your workflow is never disrupted.

Why Should Developers Choose FireMonkey for Cross-Platform Applications?

For developers, FireMonkey (FMX) is one of the most robust and flexible frameworks available for creating cross-platform applications. By using DelphiFMX for Python, developers can take advantage of FireMonkey’s graphical performance, native platform integration, and the ability to maintain a single codebase for multiple operating systems.

With FireMonkey, developers can build feature-rich desktop applications that are both visually stunning and incredibly efficient. The framework’s support for GPU acceleration ensures that even resource-intensive applications, such as those handling high-resolution images, run smoothly across all platforms. For Python developers looking to create desktop applications that combine functionality with aesthetics, FireMonkey offers the best of both worlds.

Ready to Experience AI-Powered Image Upscaling?

Are you ready to transform your images with the power of AI? The AI Image Upscaler provides an efficient, cross-platform solution for enhancing image quality, all while preserving the integrity and details of the original. Whether you’re a photographer, artist, or developer, this tool gives you the ability to upscale your images with ease and precision.

Head over to the GitHub repository today, download the AI Image Upscaler source code, and experience the future of image upscaling for yourself!