Ro-Photoshop [Fastest Image Editor & Drawing Module] (Parallel)

:art: Ro-Photoshop [Fastest Image Editor & Drawing Module]

Roblox’s Fastest Drawing Module / Image Editor

:warning: Caution: This remains a private project, and only way to get it at the moment is by buying it. Although, we might release this in 2030s to the Public for free when people overall would have access to more powerful devices and image libraries.
While we would love to make this freely available to everyone, we are refraining from doing so primarily due to the project’s current lack of funding.

This originally started as an image editor by @Puzzled3d with CanvasDraw for one of our upcoming games where any Roblox User through any platform such as Console, PC, Mobile, IPad could create Clothes for Roblox via a Roblox Game while everything is being handled by an external server along with an external database, a website for moderation & management, however, after a while we realized the performance the image editor had, was not enough to be smooth in low-end devices, so I decided to re-create his work with a totally new Module with highly optimized algorithms, and advanced techniques to provide it with the best performance possible.

This is also Roblox’s First Parallel / Multi-threaded Image Editor and Drawing Module

v0.1 by @Ranw8g7, @baconddddddd1, @Puzzled3d

Contact

.ranu.

Featured Game


Overview

What is RoPhotoshop?

Ro-Photoshop is Roblox’s Fastest graphical library that makes it easy to render pixels onto EditableImage objects. With support for almost everything that ordinary Image Editor Softwares provide you but inside of Roblox.

Originally inspired by CanvasDraw, and then OSGL.

What makes this Module exclusive is most of the features that ordinary image editors have, our module also provides (Which is where its name comes from.), and most importantly the performance it provides has no match. It also lets you use SurfaceUI inside of ViewportFrame objects, and provides you with all Roblox Vector-based Fonts that can be used inside of Editableimage objects. (This is the only Module in Roblox that provides those features).

Currently in beta, Ro-Photoshop is the fastest EditableImage library that exists and that will ever exist. Doesn’t matter how long time passes, this will remain Roblox’s Fastest Drawing Module forever unless Roblox decides to incorporate GPU functions that you could take advantage of with Luau.

This is Roblox’s only Drawing module that can handle 1024x1024 Canvas Full Drawing with almost NO FPS Drop even in low-end devices for at least its image editor that comes with it. This could also be same case for your project, if you correctly take advantage of the module functions.
It is also first its of kind to handle parallel drawing.

This is at the max potential of Roblox, this project comes from thousands of hours of studying LuauVM, CPUs, and Roblox & EditableImage. It can’t get any faster. This module fully takes advantage of Roblox & LuauVM, and CPU&GPU.

This module knows how to fully take advantage of your Hardware capabilities at the edge of Roblox Limits.


Features:

Blending Modes

Our module supports a wide range of 30+ blending modes, allowing for advanced image manipulation:

Standard Modes

  • Normal
  • Replace
  • Dissolve
  • Behind

Darkening Modes

  • Darken
  • Multiply
  • Color Burn
  • Linear Burn
  • Darker Color

Lightening Modes

  • Lighten
  • Screen
  • Color Dodge
  • Linear Dodge
  • Lighter Color

Contrast Modes

  • Overlay
  • Soft Light
  • Hard Light
  • Linear Light
  • Pin Light
  • Hard Mix

Inversion & Difference Modes

  • Difference
  • Exclusion
  • Subtract
  • Divide

HSL & Other Modes

  • Hue
  • Saturation
  • Color
  • Luminosity
  • Vivid Light

Brush Strokes

Multiple brush types for different artistic styles:

  • Airbrush Stroke
  • Basic Stroke
  • Calligraphy Stroke
  • Marker Stroke
  • Natural Pencil Stroke
  • Watercolor Stroke
  • Oil Brushes (4 Types)

Editing Tools

A variety of tools are available to enhance editing capabilities:

Selection Tools

  • Circle Select
  • Lasso Select
  • Square Select
  • Magic Wand
  • Pen Select

Drawing & Painting Tools

  • Draw Brush
  • Draw Pencil
  • Draw Square
  • Draw Circle
  • Draw Shapes
  • Fill Tool
  • History Brush

Transform & Utility Tools

  • Move Tool
  • Line Draw
  • Shape Tool
  • Zoom Tool
  • Blur Tool
  • Erase Tool
  • Eyedropper Tool
  • Transform Tool
  • Image Tool
  • Text (Vector-based, supports all Roblox fonts that Roblox TextLabels support with all of modes such as italic, bold, stroke and everything else)

Color Picker

Supports the following color formats:

  • RGB
  • HEX

Built-in Color Picker, sliders, layer system, and settings that you can use

  • Color Picker: You can change Color, Transparency, or manually enter Color via RGB, HEX
  • Layer System: Create layers, merge layers, duplicate, delete, modify opacity, hide/show, mirror on any axis, and you can also rename them.
  • Settings: Mirroring Axis, Ruler, Guide Overlays, Smoothness, Sensitivity, Size, Stroke Thickness, choosing between Pixelated Cursor / UI Cursor & Overlays & More settings.

Zooming / Moving Around

  • You can zoom in, out, and move around the Canvas. The most important feature of this is when you zoom in or out, it will keep your Cursor on the same pixel on the Canvas as before the zooming.

Save / Load / Edit / Delete

  • You can easily save, load, edit, or delete the Image Editor Templates.

Multi-player Image Editor

  • With just one click, you can take advantage of Party System that the module has, that would let several players use the same Image editor, and draw onto it.


Most of the features above are probably Image Editor-specific, and it was just a part of the Module. It also comes with everything you need for pixel manipulation, and Editableimage manipulation .



Easily Render your Image/Canvas onto 3D Models, Parts

  • By taking advantage of Editableimage DrawProjectedImage, or a very advanced method that we created before Roblox Introduced DrawProjectedImage, you can draw your Canvas onto 3D objects, doesn’t matter whether it has curves or not at Lightning-Speed.

SurfaceUI in ViewportFrame

  • Provides you with features that you can easily use to project your Canvas onto any side of the SurfaceUI in ViewportFrame, doesn’t matter what it is, again at Lightning-Speed.

Dynamic Device Optimizer

  • This is a feature that can be enabled by the Developer if they want to, it’ll take the first few seconds when every player joins the game, and optimizes the Drawing Module & Image Editor according to their devices to take full advantage of. Dynamic Device Optimizer can be integrated into your game’s loading process so players will not even notice it.

Tons of Drawing & Image manipulations functions for Developers

  • It comes with hundreds of functions that developers could use for whatever projects they have, for pixel manipulation, mass pixel manipulation, image manipulation, and tons of other stuff that will not be mentioned here. Some of the functions only exist here that Developers could use to take their project performance to another level.


Performance Comparison [1024x1024 Canvas Pixel Manipulation with 512 Radius Brush] between CanvasDraw & OSGL & RoPhotoshop

:warning: All of the Performance tests have been done in Roblox Client, as Roblox Studio Performance does not represent players performance when they play your Game. Due to Roblox Client not being able to take advantage of Native Code Generation [Machine Code] @native, additional overhead, not being able to take full advantage of all CPU threads, and many more.

-- [[ All Brush Radius: 512 ]] --
CanvasDraw

Blending Mode: Normal
Average FPS: 3 while Fast-Drawing with the Basic Brush and Brush Size: 512x512

Blending Mode: Difference
Average FPS: 1 while Fast-Drawing with the Basic Brush and Brush Size: 512x512

OSGL

Blending Mode: Normal
Average FPS: 2 while Fast-Drawing with the Basic Brush and Brush Size: 512x512

Blending Mode: Difference
Average FPS: 1 while Fast-Drawing with the Basic Brush and Brush Size: 512x512

Ro-Photoshop

Blending Mode: Normal
Average FPS: 231 while Fast-Drawing with the Basic Brush and Brush Size: 512x512

Blending Mode: Difference
Average FPS: 227 while Fast-Drawing with the Basic Brush and Brush Size: 512x512

Background Performance [Canvas at 60 FPS - Resolution: 1024x1024]:

CanvasDraw
Average FPS: 169 while moving the Cursor around with Pixelated Cursor [Radius: 512]

OSGL
Average FPS: 181 while moving the Cursor around with Pixelated Cursor [Radius: 512]

Ro-Photoshop
Average FPS: 239 while moving the Cursor around with Pixelated Cursor
 [Radius: 512]
A bit of clarification here: CanvasDraw and OSGL performance are almost the same, but OSGL sacrifices total time taken to Draw for more FPS. If you were to add a bit of task waiting in CanvasDraw, then they'd match up to almost the same performance.

This was also tested with 1000x1000, 1024x1024 Brush Size (1024 Radius), Both OSGL and CanvasDraw Average FPS were below 3, while Ro-Photoshop maintained around 240 FPS with no lag.


:information_source: While its Image Editor is an absolute killer, Pixel Manipulation without full use of the features the module provides would make the difference between these modules significantly smaller. So, this huge difference is mostly with the Image Editor that comes with it. While with pixel manipulation, it beats the speed of both CanvasDraw & OSGL with less time & better performance, however, the difference is not big without taking advantage of the functions that come with it. There might be some rare scenarios where you might not be able to fully take advantage of them, and in these scenarios, you’d still be able to benefit from the little performance boost this provides as compared to other image libraries.

This module also might not easy to use as CanvasDraw or OSGL. It is also specifically made for Image Editors, although, it can be used for Game Engines and other stuff but might not be ideal, also might not provide a huge performance boost in some cases. However, for image editors or Drawing Games, this is guaranteed to provide a performance at least 100 times faster than Roblox’s second fastest Drawing Module or Roblox’s non-RoPhotoshop Fastest Drawing Game.

This does not diminish the capabilities of CanvasDraw or OSGL in any way, nor does it undermine their functionality or effectiveness. We like both of them, and I personally prefer CanvasDraw.

For that reason, I made this module compatible with CanvasDraw for most things, meaning you can use both of them together on the same Canvas.


Feel free to try the test place for the Image Editor with only DarwPencil tool, and 2 Blending Modes: Normal, Difference at 1024x1024 Canvas resolution, and 0-512 Radius (Size) Support with any color, or alpha.
Ro-Photoshop Test Place
:warning:This is a limited version.

In case you wanna also test ordinary image editors performance:
Ordinary Image Editor Test Place #1
Ordinary Image Editor Test Place #2


This is also a performance difference between an ordinary image editor, and Ro-Photoshop Performance at 1024x1024, and big radius ( > 250 ) while Drawing


This project is still in development, we’ll continue to update it until we fully release it.
We’re open to feedback and suggestions! Let me know what features you’d like to see. :rocket:

For Drawing Games, Image Editors: It will remain the fastest, and is currently faster than any other Image Editor or Drawing Games in Roblox by over 150 times (15000%). It is also the only Image Editor that can run smoothly with no FPS drop in low-end devices.

Huge Thanks to @Puzzled3d, he was the person who created almost all of the Image Editor, and later I went through all of it.

Prices:

  • Full Version:
  1. Dropped from 3K USD (1 million Robux) to 1.5K USD (or 500,000 Robux) at the request of our beloved small Developers only for them.
  2. For Corporate, big communities it remains 3K USD (1 million Robux)
  • Obfuscated Version: 750 USD or 250K Robux
  • Demo (Limited) Version + Obfuscated Version Coming Soon For Free

If you decide to purchase it, then you’ll receive all the updates we make to it, and also get support from us whenever needed. We can also help with setting it up for your game!

24 Likes

This is amazing to see! The newer version of OSGL that I’m currently developing is even faster (like, 10x faster), so I’m excited to see how that’ll do against Ro-Photoshop :eyes:

2 Likes

Definitely faster than all the roblox drawing systems I’ve seen. Has lightning speed and good optimization being able to run on super low end devices.

2 Likes

I’ve tested it myself, and it’s incredibly fast with no noticeable FPS drops. Great job! I’m really excited for this game to be released to the public!

1 Like

chat they made rhotoshop (rotoshop?) before gta 6

1 Like

Why the gta 6?! Everyone knows its not gonna release that soon bruh (idk mabye 28837392 years later?)

1 Like

Definitely, let me know how it’ll perform once you complete it :stuck_out_tongue:

A few discord users in Discord called the results of the tests flawed, and said I using older versions of the modules, so here’s a completely new one with the latest version of each.

Performance Comparisons between latest version of OSGL, CanvasDraw, and Ro-Photoshop:

OSGL (1024x1024 Canvas - 512 Circle Radius Drawing) Video:
OSGL V1.6B:


CanvasDraw (1024x1024 Canvas - 512 Circle Radius Drawing) Video:
CanvasDraw Version 4.14.0:

Ro-Photoshop:

Wanna test it yourself?
OSGL Test Place
CanvasDraw Test Place
Ro-Photoshop Test Place

In both CanvasDraw, and OSGL with Blending Mode: Difference FPS Dropped to 1, so I didn’t bother to add them into the public test place. In case, anyone is still not sure about this, feel free to write your own Code for each in Canvas 1024x1024, Circle Radius: 512. Both APIs are easy to use, and wouldn’t take more than 3 minutes each.

Blending Mode: Normal - Canvas 1024x1024 - Circle Radius: 512 Performance Results:

CanvasDraw Average FPS: 3
OSGL Average FPS: 2
Ro-Photoshop No FPS drop felt, whatever FPS you have, it stays that.

Been tested in over 6 devices; in any module other than Ro-Photoshop FPS dropped to below 10, while Ro-Photoshop has been the only one with NO FPS Drop!

In case you write your own script for each to test them yourself, make sure the test is in Roblox Client and not Roblox Studio for the test results not to be biased.

I want to clear something up about OSGL’s and CanvasDraw’s performance numbers. I totally get that lower - end devices can struggle, but when I tested this myself, I noticed something interesting:

  • For OSGL, your example place gave me the same results you mentioned - around 100 FPS at rest, and ~3 while rendering.
  • For OSGL, when I wrote the code from scratch, (same setup: 512x512 circles on 1024x1024, drawing on mouse hold), my FPS sat at a solid 240 when idle, only dropping to ~100 during rendering.

A similar occurrence happened while testing with CanvasDraw.

OSGL Testing Code

--!optimize 2

--[[
OSGL Render Benchmark (v1.6b) - Circle Stress Test
==================================================
Tests single-threaded rendering performance by drawing
512x512 circles at mouse position while pressed.

Test Parameters:
• Resolution:  1024x1024
• Draw Call:   512x512 circle (filled)
• Condition:   While mouse button is down
• Thread:      Single (main thread only)

==================================================
]]

-- Wait a delay of 5s, in-case any Roblox services interfere. 
task.wait(5)

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

local Public = ReplicatedStorage.Public
local OSGL = require(Public.OSGL)

local Window = OSGL.Window
local Color = OSGL.color

local RED = Color.RED

local Player = Players.LocalPlayer
assert(Player)

local PlayerGui = Player.PlayerGui
local Screen = PlayerGui:WaitForChild("Screen")
local Canvas = Screen.Canvas

local WIDTH, HEIGHT = 1024, 1024

local program = Window.from(Canvas, WIDTH, HEIGHT):Unwrap()

while task.wait() do
    local inWindow, X, Y = program:GetRelativeMousePosition(Canvas)
    if inWindow and UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton1) then
        program:Circle(X, Y, 512, RED)
        program:Render()
    end
end

OSGL Circle Performance Stress Test.rbxl (80.2 KB)

Honest question - what’s going on in your implementation that’s tanking performance at rest ? Mine idles at cap until you start drawing.

Results

– Idle: [Roblox Cap]
– Drawing: ~100FPS

CanvasDraw Testing code

--!optimize 2

--[[
CanvasDraw Render Benchmark (4.14.0) - Circle Stress Test
==================================================
Tests single-threaded rendering performance by drawing
512x512 circles at mouse position while pressed.

Test Parameters:
• Resolution:  1024x1024
• Draw Call:   512x512 circle (filled)
• Condition:   While mouse button is down
• Thread:      Single (main thread only)

==================================================
]]

-- Wait a delay of 5s, in-case any Roblox services interfere. 
task.wait(5)

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

local Public = ReplicatedStorage.Public
local CD = require(Public.CanvasDraw)

local Player = Players.LocalPlayer
assert(Player)

local PlayerGui = Player.PlayerGui
local Screen = PlayerGui:WaitForChild("Screen")
local Canvas = Screen.Canvas

local WIDTH, HEIGHT = 1024, 1024

local program = CD.new(Canvas, Vector2.new(WIDTH, HEIGHT))
program.AutoRender = true

local RED = Color3.fromRGB(255, 0, 0)

while task.wait() do
    local inWindow = program:MouseIsOnTop()
    if inWindow and UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton1) then
        local XY = program:GetMousePoint()
        program:DrawCircle(XY, 512, RED)
    end
end

Once again, CanvasDraw yields similar numbers to OSGL, yet vastly different to yours.

Results

– Idle: 120FPS
– Drawing: 30 - 50FPS

CanvasDraw Circle Performance Stress Test.rbxl (131.5 KB)

Both RBXMs have been provided. Please could you provide yours? I’m genuinely curious (and I’m sure @Ethanthegrand14 would also be) why 100FPS is seemingly lost? I apologise if any of this came across as rude, but I want to understand how you got this result. It is clear that Ro-Photoshop is faster than both CanvasDraw and OSGL - and I’m not debating that. By default both libraries are single-threaded, whilst you support numerous threads, so it’s clear that you will yield higher performance. Perhaps run it on 1 thread so we can compare performance that way? If mine, as well as those “6+ devices” all yielded 3FPS or so while rendering a circle, it seems that possibly there may be something wrong with your code. Yet again, my aim is not to publicly degrade you, nor your library, I simply want to understand what’s happening behind the scenes here.

These were tested in a public game - My personal account does not have access to the EditableImage API and so I used a friends place. Feel free to publish these and try it in the real Roblox client. The difference between Studio & the Roblox client shouldn’t make that large of a performance difference, however.

3 Likes

Hey @saaawdust, Indeed it’s not rude if you’re wondering about anything, and questioning why things are the way they are. As a matter of fact, I’d encourage to continue to do so. I am very open to do that, and if anyone wants to challenge this module, I couldn’t be more open. Regarding your concerns related to the huge FPS difference, it seems to be because of your device being much faster than ours. This is your rbxl files, saved and published to Roblox, and me testing them:

Video (streamable expires in 2 days):

Watch 2025-04-12_16-23-29 | Streamable

or Download from discord directly:
https://cdn.discordapp.com/attachments/871000868277866516/1360607517142679712/2025-04-12_16-23-29.mp4?ex=67fbbbfe&is=67fa6a7e&hm=83399e9a8a70be53de39b21bcb42a8bf7474d0e1674190011c0f6272ae73b92c&

OSGL Place
CanvasDraw Place

The only difference between our test places, was that I was using RenderStepped, and you while task.wait().

1 Like

By default both libraries are single-threaded, whilst you support numerous threads, so it’s clear that you will yield higher performance. Perhaps run it on 1 thread so we can compare performance that way?

A bit late, I was trying to find a decent way to reduce ‘Cores’, the first idea was to hardcode 1 Actor, however, that wouldn’t seem too convincing so I ended up setting affinity of Roblox Studio to only 1 CPU Core to show you that it can actually run in a Nokia with no lags (~1-2 Threads), but you have to take into consideration that the whole Roblox Engine was slowed down along with it yet it had no FPS Drop.
Was Tested in Roblox Studio, I wouldn’t mind testing it in Roblox Client aswell if you would like me to do that aswell.

Here’s the video of it running in 1 CPU Core Roblox Studio:

If you have any question or doubts, let me know. Black Magic never fails to impress :pleading_face:

Hi. Since you’re now using a single thread, we can clearly see the FPS dropping to 90-100. Anyway, here’s a test place for OSGL (unrelated to the old one.)

OSGL Circle Performance Stress Test.rbxl (80.3 KB)

I would love if u can test this one :). Results from multiple devices:

  • 240 idle, 180 drawing
  • 240 idle, 152 drawing
  • 240 idle, 210 drawing
  • 240 idle, 230-240 drawing (this final device is only limited by the Roblox cap.)

Hey, In single-thread my FPS didn’t drop to 90-100 while drawing. My idle FPS was 90-100 and FPS stayed the same while drawing.

Regarding your new test place, It’s much faster, however, there’s still 40-70 FPS drop for me while drawing in it. In Ro-Photoshop even with single-threaded, there’s no FPS drop while drawing.

I’d like to also see other blending modes with this, other than just basic color with alpha 1. Since basic color only can be pre-cached very easily. Smoothening the edges of it, and implementing blending modes, brush strokes would be the next challenge. Ro-Photoshop also has dealt with all of these at lightning-speed.
At first level, I’d like to just see Difference Blending Mode.

This comment serves as a warning for all developers who wish to use this module.

I apologize in advance if this ever comes out as harsh or rude, but someone has to say it.


Firstly, note how RoPhotoshop is worded here.

EditableImages had only come out of beta late 2024, and as of writing, it is early 2025. “thousands of hours” here is objectively unrealistic. The first quote is completely unprofessional and condescending, not to mention the improper grammar used throughout the post (and this is coming from a person whose english is their 3rd language).

I will also point out things said in the second part of the quote that accomplish nothing and are not remotely related to EditableImages and Parallel Luau.

Roblox is closed-source software, and you cannot internally change LuauVM. Luau is open-source now, and I applaud the creators if they did go as far as analyzing the source code, but that would not help since you cannot change how LuauVM internally operates on Roblox. I also fail to understand how they were able to “take full advantage” of the GPU since Luau does not yet provide an interface to communicate with the GPU. The GPU is handled internally within the backend of the Roblox engine, so please enlighten me if the previous statement is wrong. And as far as I know, there is no way to uniquely identify hardware on the roblox client (if that is what is meant in the quote… as I said, phrasing is improper), nor can you actually fully utilize the CPU with Luau alone.

Also note that this type of terminology is also shared in the “Featured Game”: “It’s handled by a very complicated system with external server, a custom made database system and tons of more stuff …”


Secondly, I would like to point out the method that is used to gauge and compare the performance of RoPhotoshop with competitors. This video was shared in the original post:

It is painfully obvious that the time at which the ImageLabel updates does not match the time at which the roblox engine renders the frame. The method shown in the video measures the roblox engine FPS, not the ImageLabel FPS. To correct this, consider using RunService.RenderStepped instead, which runs at the same “clock” as the rendering of the roblox engine. Or you can also measure the time between each time you update the ImageLabel (this is called the deltaTime/framtime), and get the reciprocal of that to get the actual FPS. Now what happens without this is that RoPhotoshop can be rendering at 30FPS, but Roblox is rendering at 240FPS, and you would read the 240FPS without knowing RoPhotoshop is actually rendering at 30FPS.

Furthermore, the wording in the post regarding comparisons between OSGL/CD and RoPhotoshop is purposefully misleading. Nowhere is it mentioned that OSGL/CD are explicitly single threaded general graphical libraries. And to think that “Both OSGL and CanvasDraw Average FPS were below 3, while Ro-Photoshop maintained around 240 FPS with no lag.” has been achieved with only the addition of parallel luau is outrageous. This is an 8000% performance uplift with just the addition of parallel luau, which only adds 3-8x more workers (i. e cores). Needless to say that the hardware used when taking measurements was never mentioned either.


Finally, to be frank, this is blatantly a scam if it wasn’t obvious enough. Paying 4 figures for a half-baked roblox module should immediately raise a million red flags. And I say “half-baked” with reason, since in this quote it is very obvious that this is something incomplete from “lack of funding”, and is planned to be developed for half a decade to be released in the “2030s”.

3,000USD. 3,000USD. for “corporate, big communities”. To be taken seriously, please, consider setting the price to something sensible. If this is something that is going to be sold commercially, please note that you’re using the full trademarked name “Photoshop”.

1 Like

An OSGL-biased user commenting on this, It’s kinda obvious the results.

EditableImages had only come out of beta late 2024, and as of writing, it is early 2025. “thousands of hours” here is objectively unrealistic. The first quote is completely unprofessional and condescending, not to mention the improper grammar used throughout the post (and this is coming from a person whose english is their 3rd language).

This has been under development before even EditableImage was introduced, the clothing game development started back in 2023, regarding a bit improper grammar, It’s very obvious it’s just to bash this and being disrespectful. English is not my mother language either.

Roblox is closed-source software, and you cannot internally change LuauVM. Luau is open-source now, and I applaud the creators if they did go as far as analyzing the source code, but that would not help since you cannot change how LuauVM internally operates on Roblox. I also fail to understand how they were able to “take full advantage” of the GPU since Luau does not yet provide an interface to communicate with the GPU. The GPU is handled internally within the backend of the Roblox engine, so please enlighten me if the previous statement is wrong. And as far as I know, there is no way to uniquely identify hardware on the roblox client (if that is what is meant in the quote… as I said, phrasing is improper), nor can you actually fully utilize the CPU with Luau alone.

This takes full advantage of LuauVM, no one has said it internally changes LuauVM. There’s no need to misinterpret stuff.

Secondly, I would like to point out the method that is used to gauge and compare the performance of RoPhotoshop with competitors. This video was shared in the original post

The FPS Counter in bottom left is RenderStepped, the one in top is Roblox Stats Service FPSCounter, both are correlated.

Now what happens without this is that RoPhotoshop can be rendering at 30FPS, but Roblox is rendering at 240FPS, and you would read the 240FPS without knowing RoPhotoshop is actually rendering at 30FPS.

Ro-Photoshop, CanvasDraw, OSGL and anything else pertty much have their Rendering FPS customizable, Ro-Photoshop takes input in RenderStepped.

Furthermore, the wording in the post regarding comparisons between OSGL/CD and RoPhotoshop is purposefully misleading. Nowhere is it mentioned that OSGL/CD are explicitly single threaded general graphical libraries. And to think that “Both OSGL and CanvasDraw Average FPS were below 3, while Ro-Photoshop maintained around 240 FPS with no lag.” has been achieved with only the addition of parallel luau is outrageous. This is an 8000% performance uplift with just the addition of parallel luau, which only adds 3-8x more workers (i. e cores) . Needless to say that the hardware used when taking measurements was never mentioned either.

It wasn’t in the addition of Parallel, Parallel helped a bit, but 3 workers is max in Roblox Client anyway. Even in single-threaded version, it beat all other libraries by over 150 times in speed & performance.

3,000USD. 3,000USD . for “corporate, big communities”. To be taken seriously, please, consider setting the price to something sensible. If this is something that is going to be sold commercially, please note that you’re using the full trademarked name “Photoshop”.

We have our own upcoming games that will get released with this library, and until they’re released, this would remain like this.

You wrote a whole post full of lies, and misinterpretations.
It’s pretty sad you have to bash someone’s English because you have nothing to say other than that.