Some notes if I ever want to do something like this.

In this case I worked around it by having the Items include different text (since I had object pointers in the TStrings anyway) so I could stick to the csDropDown Style.

–jeroen

via: delphi – How to simulate Windows Theme behaviour when TComboBox uses csOwnerDrawFixed or csOwnerDrawVariable? – Stack Overflow.

In general you expect a new version of Delphi around August, this year is going to be different, Delphi XE4 is coming next week.

I just heard that next week Embarcadero is going to announce Delphi XE4, which is part of RAD Studio XE4 and will include C++Builder XE4 and HTML5 Builder.

An important change initiated last year related to Prism (Delphi for .NET) will affect RAD Studio this year, I think you won’t see Prism included in RAD Studio, of course REM Objects continue to develop their compiler and integration with Visual Studio, so you will have order directly from them.

What’s new in Delphi XE4?

Delphi XE4 will bring Embarcadero’s new ARM compiler and will allow Delphi developers to compile FireMonkey apps to iOS devices at this point. The project around this new compiler started years ago, I had the opportunity to talk about this project with many Delphi developers, so the new compiler is really new and a beginning that will allow to move Delphi language much easier to other platforms, as you already heard Embarcadero is already promising Android support and it suppose to come soon.

The iOS support is going to be better them what you saw in XE2 and you are expecting something way better. A very important point is the focus on iOS, trying to make everything you use for Windows available on iOS is not the way to go, so in XE4 you will see what is specific for iOS when developing for iOS and this is good.

Of course Embarcadero will promote FireDAC as a new feature in XE4, even it came recently on XE3 still a good point to talk about this, since FireDAC is way better them dbExpress. I blogged about that recently and you can read here.

I believe you will see InterBase for iOS on this release, even you already have SQLite on iOS devices I see a lot of space for InterBase on iOS, especially for developers that need protect their data on mobile devices.

Upgrade and pricing

Embarcadero will release all the SKUs and upgrade paths. Early this year they mention about to release iOS support as add-on, maybe you will be able to buy just this piece, let’s wait and see.

There is a webinar scheduled for next Wednesday April 24th and it will show this new release.

I will be back in the following days and will share my comments about this release.

Andreano Lanusse | Technology and Software Development
Follow me on Twitter: @andreanolanusse

Link clearance, mostly centered around “HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Ports” and “HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\DOS Devices“:

• Ghostscript, RedMon and Windows NT.
• Session Manager Subsystem – Wikipedia, the free encyclopedia.
• REG: CurrentControlSet Entries PART 2: SessionManager.
• Chapter 19: Introduction to HKEY_LOCAL_MACHINE\System and HKEY_CURRENT_CONFIG for Windows XP Registry.
• HP Communities – 3200m under Win2K Terminal Server – Enterprise Business Community.
• Repeated New Hardware Wizard Printer Detection – Windows-XP-General-Discussion – Windows-XP.
• Printer Hardware detected – Geeks to Go Forums.
• file – Printing to LPT1 in C# – Stack Overflow.
• c# – get list of printer ports – Stack Overflow.
• Retrieve list of available printer ports – C# – Source Code | DreamInCode.net.
• SerialPort.GetPortNames Method (System.IO.Ports). (it uses those registry keys)
• winapi – Enumerating a List of systems Com Ports in Delphi – Stack Overflow.
• Finding available LPT (parallel) ports and addresses in Delphi – Stack Overflow.
• Printer Connected to an LPT Port (Windows Drivers).
• how to get all network printers?? DELPHI.
• What is the best way to scan for COM ports in C#? – Stack Overflow.
• REG: Device Driver Entries, PART 1.
• Silverlight 4 and parallel port – Stack Overflow.
• Adresse von LPT herausfinden – Mikrocontroller.net.
• VMware Communities: LPT ports problem.
• microsoft.public.win2000.printing: Re: registry entry – parallel port.
• c# – Detect if parallel port exists – Stack Overflow.
• Parallel Port Control with C# .NET 2.0 – CodeProject.
• NullifyNetwork – Blog – Opening physical devices with C# dot net: The Missing Bit….
• Parallel Port Control with Delphi: Parallel Port, Delphi, LPTPort, Device Driver.
• [C#] How to programmatically find a COM port by friendly name « DarioSantarelli.Blog(this);.
• BAFO 1284 pritning cable: writing byte to parallel port.
• How do I redirect the LPT1 port to a network printer in Windows 7 – Microsoft Community.

–jeroen

It’s not exactly a ‘leak’ given it comes from an official promo video, albeit in Russian, but anyhow, the US pricing for Delphi XE4 has come out:

See here (for some reason, the video couldn’t show on Firefox, my usual browser, but it ran fine in Safari). In a nutshell, the XE4 upgrade will be a ‘nominal’ $49 for XE3 Professional edition owners uninterested in iOS support, or $499 if they are. In contrast, the upgrade cost from XE3 for Enterprise and above will be a flat $499. Slightly disappointingly (well, in my view at least), nothing clever has been done with the Starter edition – that remains Win32 only.

Does $499 (I shan’t guess the exchange rate for outside the US) fulfil the promise of iOS support being a ‘low cost add-on’ for XE3 Professional owners? Probably not, and while I’d prefer it lower, I’m not sure it’s particularly expensive for the market either:

• RemObjects are currently running a ‘limited offer’ promotion for getting Oxygene for Windows, OS X, iOS and Android for $499. While this is more platforms than Delphi, at least for now, you’re only getting a vaguely Delphi-like language – ignoring the lack of a shared visual component library (which RemObjects are no doubt quite sincere in dismissing the very idea of), there’s no shared RTL either, at least at the level of Delphi’s, let alone .NET’s.
• Xamarin sell their eponymous Mono-based tools for $299 per platform for ‘indie’ developers, and $999 per platform per seat for ‘business’ customers. Since only the ‘business’ (or beyond that, ‘enterprise’) edition comes with Visual Studio integration, if you want that, you’re looking at $2,697.30 (!) for all supported platforms (this includes a multiplatform discount). On the other hand, unlike Oxygene, you are buying a commercial licence for not just a language (C# in Xamarin’s case – and a very fine language it is too), but an extensive RTL (i.e., their implementation of the .NET BCL) and a dedicated IDE, which Xamarin ships alongside (or in the case of the ‘indie’ edition, instead of) its VS integration.

Of course, beyond pricing, there is the quality issue to consider too. Put briefly, it’s all very well promising the moon, but if you end up delivering a trip to a boggy field instead, the original promise will backfire. Time will tell…

Hello everyone!

1. There is a contest for best open-source project on Polish portal http://www.spinacz.edu.pl/. Please take a moment to vote for our Castle Game Engine!

2. Our engine was submitted to devmaster.net, with lots of information and screenshots. You're welcome to review and rate us there!

3. We also want to remind that we have a Google+ page about our Castle Game Engine, you can follow it to see (a little more frequent) news about our engine development.

New engine features in development:

1. Mac OS X with native look. This is already much more user-friendly than our previous GTK-based releases for Mac OS X. See development details. Hopefully, this will allow us to release next view3dscene as normal Mac OS X application, that will be trivial to install for Mac OS X users.

2. Network (http) support. Most "FileName" parameters and properties are now URLs. You can use protocols like file: and http: and data: everywhere, and of course http will be automatically downloaded. Try view3dscene from snapshots, enable "Preferences->Download Resources From Network" and then use menu item (Ctrl+L) to load URL, or pass URL on the command-line.

   This is a little user-unfriendly, as the downloading is blocking (the process waits for the download to finish, instead of letting you enjoy the game and download in the background; there isn't even any nice way to cancel the download, or even notification about it, except for --debug-log message). For this reason, it is disabled by default: you have to explicitly allow it by "Preferences->Download Resources From Network" (in code: CastleDownload.EnableNetwork variable).

   For some test scenes on the Internet, try e.g. Inline demo or Texture demo or AudioClip demo. (from ConformanceNist X3D Examples Archive). Or see our demo models through http, by browsing through SVN http link.

   view3dscene automatically downloads the model, as well as all linked resources (textures, inline models, sounds, scripts etc.). You can also use VRML/X3D Anchors to jump to any URL (for example, you can jump from a local file to a model available through http). Also data: URI handling is now more uniform. Also the engine uses now MIME types more, instead of merely file extensions. This makes us work with http transfers, and improves cooperation with data: URIs.

   In a game, you could also use URLs inside files like level.xml and resource.xml. For example, you could distribute now a level.xml file that contains URLs to levels on your server, downloaded each time.

3. Clipboard (Ctrl+C, Ctrl+V, Ctrl+X in message boxes, especially handy to copy/paste URLs). For developers: use Clipboard.AsText property. Implemented for CastleWindow WinAPI, GTK, LCL backends.

4. CAD level 2 support (CADXxx nodes).

5. Improvements to 2D rendering. They also workaround crashes on some Mesa 9 drivers.

6. Support for 8 and 16 samples for anti-aliasing, there are (at least NVidia) GPUs supporting it.

7. Renamed our event Idle to Update.

   This reflects our implementation and usage of this event clearer. This event is for continuous tasks, called even when the application is not "idle" (when application is processing something, like mouse moves). Our Update event doesn't correspond 100% to normal (as used by LCL or GTK) meaning of "idle" (which is also evidenced by code if TCastleWindow LCL and GTK backends, that cannot simply use LCL/GTK "idle" concepts to implement our Update).

8. TCastleControl.AggressiveUpdate* are removed. The (simplified and improved) version of this mechanism is now always "on" and automatically makes mouse look work better. It's still not perfect (it seems LCL event loop is just too slow to process events during mouse look fast enough), but it's better now. If you want perfectly smooth mouse look, you should still consider TCastleWindow instead of TCastleControl.

Just noticed this:

http://docwiki.embarcadero.com/RADStudio/XE4/en/What%27s_New_in_Delphi_and_C%2B%2BBuilder_XE4

I don’t know whether someone has jumped the gun or not, but from a ‘conceptual overview’ and ‘getting started’ POV it’s pretty comprehensive.

We’ve heard lots of noises about Embo’s pending Delphi support for iOS over the last 6 months or more and now the wait is over.

The iOS support has arrived, but not as the largely expected add-on to XE3, but instead as a new version: XE4 (available with or without iOS support). Delphi XE4 has arrived (along with C++Builder XE4 and RAD Studio XE4) and now targets:

• 32-bit Windows
• 64-bit Windows
• 32-bit OS X
• iOS Simulator (Intel)
• iOS (ARM)

There is a flurry of activity about this new release over the blogosphere and here’s a summary of the key points regarding information about the product and regarding the product itself.

Information

• The product will be announced to the web during a launch webinar on Wednesday (24th April, 2013). Full details can be found here and the registration page is here.
• The product landing pages for Delphi, C++Builder and RAD Studio have been updated to cover the new version.
• The formal press release announcing the new version can be found here.
• XE4 documentation is online with the landing page at http://docwiki.embarcadero.com/RADStudio/XE4/en.
• iOS tutorials can be found here.
• For those with a serial number you can download the RAD Studio XE4 .iso DVD image from download page or directly from this link.
• Trial versions can be obtained from here for RAD Studio XE4, here for Delphi XE4 and here for C++Builder XE4. As well as the regular trial versions there is also an AppWave trial (so-called Instant Trial), which is set up in minutes and can be removed trivially; the link is here.
• What’s New in Delphi and C++Builder XE4.
• What’s New In C++Builder 64-bit Windows.
• Marco Cantú’s white paper The Delphi Language for Mobile Development is available from here and you can see the Table of Contents in Marco’s post here.
• Delphi Prism aka Embarcadero Prism, the Embarcadero-branded version of RemObjects Oxygene for .NET, is no longer supplied with RAD Studio. RemObjects will be happy to continue a relationship with you, and tempt you to their approach to multi-device support, which revolves around Oxygene for .NET, Oxygene for Java and their forthcoming Oxygene for Cocoa.

Product details

The main thrust of this release is the Delphi support for iOS, specifically two new cross-compilers that support targeting the iOS simulator (Intel) and native iOS (ARM) called dccios32.exe and dcciosarm.exe.

As you might expect there have been a raft of changes in FireMonkey to support this wider platform range and improve the existing platform support. Indeed FireMonkey has now changed from being known as FM² to now being FM³. The online help has much information on the changes to FireMonkey.

The IDE has new mobile form designers (no longer floatable) and new target platforms to get your app on the simulator or iOS device. Of course FireDAC is in the box too.

InterBase ToGo is now supplied as an option for an embedded database in your application, including iOS applications. Note that InterBase ToGo requires a license to be bought, whereas IBLite does not (and also does not support encryption, more than 1 core, more than 1 connection, etc.). More info on InterBase ToGo is available in this quick-start guide.

iOS support has been added for SQLite, IBExpress and the MIDAS client components (notably TClientDataSet).

The iOS compilers introduce the Next Generation Delphi language, which some of you will have seen hints of in the Delphi XE3 source code via the NEXTGEN conditional compilation symbol that is checked for in many places. This Next Generation Delphi support is currently only available in the iOS compilers, though it’s a safe bet we’ll also see it in the Android compiler, whenever that appears.

The Next Generation Delphi compiler takes the opportunity to off-load some aspects of the Delphi language that are a little archaic and at the same time bring in some new helpful features.

Things that have gone/changed include:

• Some of the many string types have gone (AnsiString, UTF8String, RawByteString, WideString, AnsiChar, PAnsiChar, PWideChar, OpenString, ShortString) leaving just the basic type string , an alias for UnicodeString.
• Pointer support is gone. For interfacing with external library APIs there is a new TMarshaller record, which works with the TPtrWrapper record.
• Strings are 0-indexed instead of 1-indexed by default. It is recommended you employ TStringHelper (introduced in XE3) to work with strings as it knows about the string indexing on the different platforms.
• Strings are to be considered immutable. Currently you can change string contents but will get a warning for your trouble. This is to encourage you to change the code to use a TStringBuilder to build a new string. Future versions may change the warning to an error.
• Inline assembler support is gone.
• You are advised to rewrite code that uses with as this is likely to be removed in future versions. I can see the benefit in enforcing this, as I have bumped into so many scope errors caused by over-zealous with usage over the years…

New things include:

• Automatic Reference Counting (ARC) for objects.
• Weak references
• Atomic intrinsic functions:
  • AtomicExchange
  • AtomicIncrement
  • AtomicCmpExchange
  • AtomicDecrement

• {$ZEROBASEDSTRINGS ON/OFF} controls whether 0-based or 1-based string indexing is active. You can, for example, use this to force 1-based indexing in mobile code that you haven’t yet updated
• {$EXTENDEDCOMPATIBILITY ON/OFF} allows use of Extended data type on platforms that do not normally support it (Win64 and iOS). The given support offers the expected 10 bytes storage but doesn’t offer the higher floating-point support that Win32 Extended gives.

• [volatile] to indicate the field may be changed by other threads (it’s a hint to the code optimiser).
• [weak] to mark a weak reference.
• [Ref] to ensure constant parameters are passed by reference rather than by value.

Given these changes there is a page that talks about how to migrate code from the desktop to iOS.

Taking all the above onboard, it looks currently like Embo offer a common component framework (also, slightly confusingly, referred to as a platform) to program against for different target platforms (Win32, Win64, OS X, iOS) in FireMonkey (aka FMX aka FM³). As for your Delphi code, however, it would currently appear that desktop code and mobile code will look a bit different, thanks to the string changes (1-indexing to 0-indexing and the push towards immutability) and of course the specific form factors of the UI on the respective platforms.

So, you build a mobile UI and you build a desktop UI. With the desktop UI you take great care to ensure the app looks like a Windows app when compiled for and running on Windows (menu layout, button order and placement on dialogs), and looks like a Mac app when compiled for and running on OS X.

Then when you come to build the code base, you write it once for the desktop using all the standard Delphi-desktop paradigms of creating objects and ensuring they are destroyed with try/finally/free/end. On the mobile side you skip all that and let objects be cleaned up by ARC, and ensure weak references are specified where appropriate.

I’m sure the desktop compiler will catch up with these changes at some point, but in the interim there is a requirement for quite a bit of conditional compilation, or making use of no-op calls in the mobile code. And if/when the desktop compiler catches up, that will potentially force a big hit in massaging desktop code into the new realm of Next Generation Delphi.

It’s all a bit up in the air as to how things will pan out, but to my eyes currently, the only common thing is the FireMonkey framework. Other than that, the coding and design looks to require dedication per platform targeted. Which is no bad thing. In my opinion, when targeting a given platform you should put some effort into making sure the application works gracefully and looks in keeping with its peers.

With that mindset in place, the iOS support looks pretty neat and the changes to the language make Delphi behave a little more like many of the other popular languages in existence. I’ve certainly got no issues with kicking out with and dropping to a single string type. Let’s just be careful to not play the “write once run anywhere” card too frequently, eh?

This time you didn’t have to way a full year to see a new Delphi release, 8 months after XE3 release Delphi XE4 is out.

iOS development is the major topic of course and bring the second version of FireMonkey to iOS, a lot of expectation on this topic specially after XE2.

Also there is a bunch of new stuffs to talk about, like:

• New Delphi compiler for mobile platform, which brings several changes in the language and set a future path to the Delphi language, obvious these changes will affect desktop development in the future and you need to start learning about that now.
• The SQLite and InterBase support for iOS
• ClientDataSet available on iOS
• Several FireMonkey changes for iOS, componentes, new classes
• Etc..

RAD Studio XE4 now includes only Delphi, C++Builder and HTML5Builder. Delphi Prism is no longer part of RAD Studio, the name is dead and from now you have to refer to Oxygene from RemObjects. You can check the official communication from RemObjects here, where Marc Hoffman provide more details about the future related to .NET development with Oxygene (old Prism) and their support to iOS and Android development.

Trial is already available here or if you prefer download the full Delphi and C++Builder ISO here.

The Delphi XE4 documentation has a extensive list of What’s new in Delphi and C++Builder XE4, below the table of content:

• 1 Getting Started with iOS Application Development (iOS Tutorials)
  • 1.1 Setting Up Your iOS Development Environment
  • 1.2 Using Basic iOS User Interface Elements
  • 1.3 Using iOS Device Functionality
  • 1.4 Accessing a Database
• 2 FireMonkey Changes for XE4
  • 2.1 Components for iOS
    • 2.1.1 Camera for iOS
    • 2.1.2 Magnifier Glass
    • 2.1.3 Phone Dialer for iOS
    • 2.1.4 Pickers for iOS
    • 2.1.5 Text Editing in iOS
    • 2.1.6 Virtual Keyboard for iOS
    • 2.1.7 WebBrowser for iOS
  • 2.2 FireMonkey Frames
  • 2.3 Touch and Gestures for iOS
  • 2.4 New TListView Component, Compared to Existing TListBox Component
  • 2.5 Media Actions for iOS
  • 2.6 Native Styles for iOS
  • 2.7 Using Styles in XE4
  • 2.8 Mac OS X Fullscreen Mode
  • 2.9 Sensors
  • 2.10 Text Layout and Text Service Enhancements
    • 2.10.1 Text Layout
    • 2.10.2 Text Service
  • 2.11 FireMonkey Services
    • 2.11.1 Platform Services
    • 2.11.2 Notification Center for iOS
  • 2.12 Margins and Padding for FireMonkey Controls
  • 2.13 New FireMonkey Units
  • 2.14 Refactored FireMonkey Classes
    • 2.14.1 Caret Property Now Published
    • 2.14.2 HScrollBar and VScrollBar Now Protected
  • 2.15 Improvements in Action List editor
  • 2.16 FireMonkey Advanced Platform-Independent Scrolling Engine
• 3 Platform Assistant (PAServer) Changes for XE4
  • 3.1 Installer and Name Changes on the Mac
  • 3.2 Help Reorganized for PAServer
• 4 Delphi Compiler Changes for XE4
  • 4.1 Two New Delphi Mobile Compilers for iOS
    • 4.1.1 Differences between Delphi Desktop Compilers and Delphi Mobile Compilers
  • 4.2 New Delphi Compiler Conditionals
  • 4.3 New Delphi Compiler Directives
  • 4.4 New Delphi Compiler Attributes
• 5 IDE Changes for XE4
  • 5.1 New FireMonkey Mobile Wizard
  • 5.2 iOS Target Platforms Supported
  • 5.3 New Mobile Form Designer
  • 5.4 Connection Profiles and SDKs (Replacing Remote Profiles)
    • 5.4.1 API Implementation of Connection Profiles and SDKs
  • 5.5 IDE and Project Options Changes
    • 5.5.1 Form Designer
    • 5.5.2 Application Options
    • 5.5.3 Version Info
    • 5.5.4 Provisioning
    • 5.5.5 Delphi Compiler Project Options
• 6 C++ Compiler Changes for XE4
• 7 Database Changes for XE4
• 8 DataSnap Changes for XE4
• 9 LiveBindings Changes for XE4
• 10 Run-Time Library (RTL) Changes for XE4
• 11 Debugger Changes for XE4
• 12 Application Samples Changes for XE4
  • 12.1 New FireMonkey iOS Samples
  • 12.2 New FireMonkey iOS Code Snippets
• 13 Online Help Changes for XE4
  • 13.1 Checkbox to Display or Hide Inherited Members
  • 13.2 PAServer Help Reorganized
  • 13.3 Some Notable New Help Topics
  • 13.4 Some Notable New Code Examples
• 14 See Also

That’s it for now.

Andreano Lanusse | Technology and Software Development
Follow me on Twitter: @andreanolanusse

You might think the below question on CodePage zero is Delphi related, but most of it is not.

It is about CP_ACP (the currently Active CodePage, and has some interesting observations:

• It can vary accross systems
• It can be changed without reinstalling Windows
• Delphi 2009 sometimes did a bad job with it (but Delphi 2010 and up are OK)

CP_ACP is the major reason people have difficulties exchanging the data in text files between applications on different computers.

Oh and you can get the actual value of the active Active CodePage using GetACP, but CP_ACP isn’t always slower..

–jeroen

via: delphi – What is Codepage 0? – Stack Overflow.

The big news for Today, April 22nd, 2013 is the release of RAD Studio XE4 which includes the new Delphi for iOS. I thought it would be fitting to talk with Marco Cantu, long time Delphi author and supporter who recently took over as the Delphi product manager.

So I won’t forget, as the static in different languages varies in meaning:

Static on class methods makes them assignment compatible with plain old function pointers.

Thanks Moritz Beutel for initially posting this.

–jeroen

via:

• oop – Does Delphi’s static keyword have any point in native-only code? – Stack Overflow
• static in different languages – Stack Overflow.

For a few weeks now, an experimental JIT compiler has been available in the DWScript SVN for 32bits code. A more detailed article into the hows and whats and WTFs will come later.

Consider this article as an extended teaser, and a sort of call for test cases, benchmarks and eyeballs on the source code.

Following benchmarks were compiled in XE2 with full optimization, no stack frames and no range checking. Absolute values aren’t meaningful, just consider them relatively.

Mandelbrot fractal

(lower is better)

Delphi XE2-32bit : 515
Delphi XE3-64bit: 162
DWScript JIT 32bit: 281

The JIT was initially tested on the Mandelbrot benchmark, so that’s one of the cases where JITing is almost complete, with the exception of the SetPixel() call.

SciMark 2

(higher is better)

Delphi XE2-32bit : 507
Delphi XE3-64bit: 682
DWScript JIT 32bit: 215

Delphi version uses pointers, DWScript version was slightly updated to use dynamic arrays instead  and JITting is partial at the moment.

The benchmark involves fairly large matrices, and DWScript use of Variant (16 bytes) rather than Double (8 bytes) means the data no longer fits in the CPU cache, which partly accounts for the poor showing of the JIT.

Array statistics

(lower is better)

Delphi XE2-32bit : 208
Delphi XE3-64bit: 47
DWScript JIT 32bit: 63

This test measures of execution time of the following code (fully JITted), which computes the base values for common array statistics (range, average, deviation, etc.). The Delphi 32bit compiler really suffers because of Min/Max (despite having inlined them).

// "a" a floating point array of non-ordered values
for v in a do begin
   s := s + v;
   s2 := s2 + v*v;
   mi := Min(mi, v);
   ma := Max(ma, v);
end;

What next?

The DWScript JIT compiler relies on SSE2 to outperform the Delphi 32bit compiler, its current main limitations are:

• JIT centers around floating point and a limited subset of integer and Boolean operations, the rest isn’t JITted yet.
• Function calls aren’t JITted at the moment, and neither are a variety of other statements.
• The JIT works with the same data structures as the interpreted engine, that means script debuggers and everything else works on JITted code as if it was still interpreted, but that also means the basic data unit is still the 16 bytes Variant at the moment.
• The JIT register allocator is currently limited to floating point (ie. no integer or pointer allocations).
• DWScript Integer type is 64bit sized, so for 32bit values, Integer performance is lower than what Delphi 32 can do, even though the JIT can generate typically faster code for it than the Delphi 32bit compiler does for Int64.

The JIT also suffers against a 64bit compiler as there are 64bit CPU instructions (and registers) not accessible in 32bit mode, but a 64bit JIT should be able to go farther.

If you’re interested and want to help, I’m currently looking for benchmarks and test cases, if you have code that compiles in both Delphi and DWScript,  particularly on integer maths (encryption, etc.) or object-oriented manipulations (graphs, trees…) that could help. You’re even allowed to have the Delphi version use pointers and other tricks, the comparison doesn’t need to be fair