Soon Delphi 2010 "Weaver" will enter in beta. (See http://www.embarcadero.com/products/beta_programs.php)

Which would be your most wanted features for the next release of Delphi?

Mine (from top of the head):

  • tooling for synchronizing the representations of DB schema (aka. DB metadata) in code and in database
  • language enhancements:
    • CASE on non-ordinal types
    • lazy evaluation
    • mixins
    • AOP (aspect oriented programming)
  • VCL enhancements:
    • DB enhancements (TDataSet, TClientDataSet - faster, more feature rich)
    • OPF/ORM on native side
    • (more) containers, classes (using generics)
  • IDE enhancements:
    • Runtime Object Inspector using the already registered editors to allow WYSWYG debugging of the objects/classes (and generally a better debugger)
    • Code management tools
    • Refactoring assistants
    • Find unused code (ok, here we need support from linker)
  • 64-bit compiler

...and many many more :-)


UPDATE: There are some sneak previews at http://wings-of-wind.com See for yourself.

58 accepted

Stable IDE

I remember working in Delphi 7 when it was still Borland Delphi. It was a great little IDE, very reliable, and still one of the fastest compilers I've ever used (almost scary fast!).

After the IDE was sold the Codegear, the company worked on packing the IDE with bulletpoint features. When me and the other Delphi developers on my dev team started on Delphi 2007, we seriously lost hours of work everyday because the IDE was so buggy, and it took so long to restart. There were days when the IDE would crash every 10 minutes, and it constantly leaked memory (even when it was sitting idle!) Delphi 2007 crashed with enthusiasm, and I'm convinced Delphi 2007 would have put sent Delphi to its death if it weren't for the one killer feature, CodeRush (and even that was buggy).

Delphi 2009 was an improvement, although it wasn't backward compatible with our Delphi 2007 projects. It didn't crash as often (not more than twice a day), but still was substantially less stable than Visual Studio, Eclipse, IntelliJ, or any other IDE I've ever used.

More than anything, I'd give up a few features in this release just to have the IDE fumigated for bugs and shoot for rock solid stability.


64 bit compiler.


A working help file.


First and foremost, an IDE is a text editor, and a real text editor never blocks. As long as there isn't a dialog box open, there's no reason why you should ever be unable to edit your code. Andreas Hausladen has some tricks that help out a bit in that, but it's still fundamentally the wrong solution. If the IDE needs to do something that's gonna take 30 seconds or so to build CodeInsight data set or do whatever it's doing when I hit F1 for the first time, it ought to do it in a background thread and leave me free to write more code.


Cross platform compilation.


Source code formatter, SVN integration


Multi-core support.


Support for regular expressions.


faster IDE by throwing out .net and stop following the ms vs style!!!


Stable faster IDE with enhanced refactoring support.


Improved Syntax highlighting:

Visualise {$IFDEF} ... {$ENDIF} by graying-out/hiding/folding pieces of code that are not going to be used.


Make it easier to create, install and spread components and packages.

  • Let component creators create things in a more graphical way.

    • Why can't I rightclick the component palette and say: "Add new"?
    • Why can't I rightclick an icon and choose "change icon", and be able to choose a standard type of image (gif,png,jpg,bmp)?

      Even the most advanced user is never going to find out how to change the icon of a component (create a .dcr file, blabla) without reading it in the documentation or on a website. It's totally unintuitive.

  • Create a new package format that contains all files and information that is needed to install it, so that end-users (Delphi developers) don't need to bother chosing the right package for their Delphi version, adding paths, compiling in the right order, etc.

Just have required files and folders in a certain structure, zip it and rename it to dpz.

People should be able to just double-click on such a file and have the stuff installed, in the same way that you can just click on a winamp skin to install it. Or it could be a bit like .rpm or .deb files on certain linux distributions.

(Why do I come up with this? A few weeks ago I had to explain to a very experienced but non-Delphi developer who was going to help out on a Delphi project how he had to install certain packages before he could get going. To make things worse there were 2 Delphi versions installed with conflicting .bpl files in paths hidden far away. By the time we were done, I think he already had enough of Delphi)

  • It would be very nice if there'd be a central repository for packages, probably best maintained by Embarcadero. It could partly be for Delphi what AppStore is for the iPhone.

    It would have the following functions:

    • Have dependencies between packages automatically resolved;

    • Enfore a certain namespace for all code and check for conflicts before accepting contributions;

    • Third party component developers can sell or give away their stuff via this place;

    • Delpi developers can easily find stuff;

This could be via a website, but it would also be neat to have it integrated into the IDE.

Where you search for a component in the tool palette, you'll see all registered components. Those that are not installed yet are just grayed out. Clicking such an icon downloads and install the right package.

This would be a giant productivity booster.


Object friendly databinding and desingtime interaction.

Current databinding approach belongs to BDE times! We don't even have properly working DB independent dataset! That old architecture is discouraging programmers to develop modern layered architectures and OPF/ORM stuff. I mean seperation of Gui and bussines objects. Though this is pointless if you are happy to use TDataset descendants as bussiness objects! Some delphi programmers still think they can provide layering with just using remoting facilities (RemObjects, Datasnap) and codegear invests on Datasnap and Dbexpress! Collective delirium!

For Codegear : No layering := No enterprise customers!

For Delphi programmers : No layering := Time for retirement!


A built-in profiler.

Why do we have to be held hostage by AutomatedQA with their AQTime program as the only non-invasive profiler that's available. It's not Delphi specific and they still (as of 20 Mar 2009) do not integrate into the Delphi 2009 IDE.

It doesn't feel right paying more for just a profiler than I did for my upgrade to Delphi 2009. I'd sooner pay Embarcadero $300 more for the upgrade with a profiler, than pay AutomatedQA twice as much for just AQTime.

Also see "Profiler and Memory Analysis Tools for Delphi": http://stackoverflow.com/questions/291631/profiler-and-memory-analysis-tools-for-delphi

and "Delphi Profiling tools": http://stackoverflow.com/questions/368938/369945#369945

A response just posted to: "How Does AQTime Do It?" by Andre Mussche tells of the open source non-invasive profiler called asmprofiler that Andre developed. I commented back that he consider donating it to Embarcadero for their inclusion with Delphi. Or he could market it himself (probably successfully) for $200 a pop.

Vote Here!


Lambda expressions. (nearly there with anonymous methods)


Garbage collection.


A true ternary operator, which (when short-circuit boolean evaluation is active) does only evaluate one of the expressions.


We can post them to user voice: delphi.uservoice.com Might make it easier to track votes long term.


Official support for the firebird database would be nice.


Beg/borrow/steal CodeRush from DevExpress and make it part of the standard IDE. Code templates are a huge step, but I am no where as productive as I was using D6+CodeRush.

One more thing, a JSON Databinding Wizard that turn a JSON file/config into a binding class so I can..

Customer := NewCustomer();
Customer.FirstName := 'Bob';
//set other fields/complex collections
StringToSendToJsonWebService := Customer.ToJson();

New object scopes: private published and protected published. New components added to forms would be declared private published instead of the current standard.

Right now, everything that's published is also automatically public. This is a mixture of two different paradigms (OO scope visibility and RTTI) that address different concerns and different access models, and don't need to be linked. Visibility scope (private/protected/public) only matters at compile time, while RTTI (run-time type info) only matters at runtime. Artifically joining the two at the hip promotes really bad OOP, especially in form design issues. For backwards compatibility reasons, "published" would probably need to still mean "public published", but that should no longer be the default, or the only choice.


Sort of minor, but it would be nice if Delphi started up faster.

Delphi 4 used to start up in under 2 seconds. But Delphi 2009 takes about 30 seconds to start up.

Now it feels a bit like starting your computer. Press the On button, go away and do something else for 5 minutes, and then come back.

  1. A more stable and faster IDE
  2. Support for regular expressions
  3. Source code formater under the IDE
  4. A better help system including a real sample code exemple
  5. Extend VCL to graphic/picture/video/OMR/OCR
  6. A except/finally in same code block like:


MyObject := TMyObject.Create;
  raise something



Improved support for properties. Properties are basically an abstraction that allows an object to appear that it's got a bunch of public data members available for the coder to use, (making an object look like a record, back before records got scope and properties too,) instead of ugly get/set methods for everything like you have to use in C++. Problem is, the abstraction leaks in a few places, but they ought to be pretty easy to plug.

For example, there's no good reason why you should ever be unable to pass a read/write property to a var parameter. If it directly accesses the same field for both read and write access, it's trivial. Otherwise, it could be done easily enough with a small dose of compiler magic. (Allocate a temporary variable on the stack, read, copy the value, pass the copy to the function, retrieve the result and send it to the property's write access.)

Also, whoever created the current implementation of array properties oughtta be taken out and shot. They're written as if all "arrays" are really something else, so you need a get and set method to use them. That's actually been true in my own code a grand total of once. If I have a real array inside my object, I ought to be able to declare read and write access to it directly, just like any other data member:

  FMyArray: array[1..10] of TMyObject;
  property MyArray: array[1..10] of TMyObject read FMyArray write FMyArray;

Also, it would be really nice if this would compile, just to simplify things a little:

property MyNumber: integer read write FMyNumber;

Better (and less complicated) RTTI


Subranges in case statements:

   Terrain = (Room, Wall, Corridor, StairUp, StairDown);

   Stairs = StairUp..StairDown;

Case Terrainvar of
      Stairs : DoSomething;

Here's one that REALLY bugs me, but should be a simple one for them to add.

In the editor, you can right-click on a variable and select "Find Declaration". That is really useful and convenient.

But when debugging, it isn't a right-click option. Why not?

Please include that!!!

  • A better debugger.
  • A much improved Help file. D7 help file was a nice one. The current one is a pain.
  • A search box at the top of the VCL toolbar so you can type the name of a component and filter the palette.

Two words: Native LINQ.


A customizable debugger (http://msdn.microsoft.com/de-de/library/zf0e8s14.aspx).


Here's a thought, don't add anything new, just catch up on all of the Quality Central issues that need to be addressed.

  1. Databinding like .NET. No more TDataset hell!

  2. Multiline strings in the code

    s := 'A String';

    multiline := "I'm the first row

    and I'm the second row

    and here there is the third row"; //Note " instead of '

  3. Simpler e stronger RTTI

  4. Simpler sintax for anon method

  5. Mixins like ruby.

  6. Skin for VCL

  7. Some high order functions like ruby, python or PHP

  8. Garbage collector for some specific type (es. if a class implements Interface "IManaged", object created from that class will be managed)

  9. Contracts, like Delphi Prism

  10. Inline variable declaration like Delphi Prism

  11. Workaround for "Circular unit references" error.

  12. Cross-compiler (at least for console/service application)

  13. No limit for constant string size.

  14. Integrated ORM (with or without designer support)

  15. Integrated Profiler

  16. Integrated Serialization system (Every object can be serialized as XML, JSON, Some Native Type. etc)

  17. Still better DataSnap

  18. Revamped TDBGrid

  19. Stronger support for SOAP

  20. Some support for build RESTful application type (something more of webbroker)

  21. Integrated UML tool for Class Diagram (at least) with code generator for REAL Pascal code (not like Together)

  22. Many Thanks For Your Work!


XML Serialization / Deserialization.


a MUCH better HELP SYSTEM !!!!! PLEASE !!!


Improved class modeling tool.


A version number that's actually a number, that the preprocessor can treat as a number. Anyone who's ever had the joy of having to dig through and extend include files when the new version of Delphi suddenly won't compile an old 3rd party library will know exactly what I mean and why it's important.


Global search and replace in the IDE - there is no way to do Delphi 2006 see link text


Should GExperts Functionality be Incorporated into Delphi?



More examples in the help files


Unicode switch. As in Visual Studio. There are a list of build options in VS like:

  1. MyApp (Debug)
  2. MyApp (Release)
  3. MyApp (Debug - Unicode)
  4. MyApp (Release - Unicode)

I would like to have such an option to decide whether the app is Unicode or just plain ANSI build at compile time.

  1. Faster and non-blocking code insight.
  2. Packages without needing to compile with all the run-time packages. Just the one with the new functionality.I compile application without the run-time packages, but I can use just one, or two additional packages.
  3. Fix IDE bugs.

Automatic deallocation without garbage collection.

Instead of this:

var o:TMyObject;
    FreeAndNil (o);

It would be nice to get:

var o:TMyObject;
  o:=local TMyObject.Create;

Here, the keyword local forces the compiler to deallocate the object before the function finished. It would also enable such constructs:

(local TMyForm.Create(nil)).ShowModal;

This would create the form, show it modally, and deallocate it again in a deterministic/plannable/non-random way.


Managed records, so that I can have constructors and destructors for stack-based variables without fiddling around with try ... finally, and without the overhead that using interfaces for this purpose has.

  1. Interfaces for most VCL classes, f.e. IStringList, IDataset, IField, IDbControl.
  2. Support for Windows 7.
  3. More intelligent Refactoring tools(like ModelMaker Code Explorer has).

Since Delphi 7, a lot has been changed. But I still miss old clean IDE.

  1. Remove all Visual Studio like elements from IDE and create your own style.

  2. Design your own fast, stable and informative help system. A development environment uses a competing product's help system. Is this logical?

  3. Give us the tools of the future, as in pre-Delphi 7 era.

  4. Leave the .NET in the dust. Yesterday I needed a freeware CD burner, searched the net and found a software. I tried to install it, but it said it requires .NET framework 2.0, which I don't have. It redirected me to a site where I needed to download a huge package to use a 2 mb program. I removed it instantly. No one can explain me why I should install a 300 megabytes of framework to run a 2 megabyte executable.

These are my requirements for a new version of Delphi. Unless these are satisfied, I won't use another version of Delphi again.


Native PostgreSQL support !!


Better intellisense/auto-complete/(whatever Delphi calls it).

Getting class members is very useful, but autocompletion of local variables / enums / etc. would be very welcome.


Could be stupid but I really miss a TDBLookupLabel component !


My top three feature requests:

  1. ability for Delphi 2010 to use VCL components created by C++ Builder 2010

  2. cross platform server-side binaries (e.g. ISAPI Windows .DLL and Linux .so)

  3. ability to link to C++ Builder .OBJ files, even if it is C++ (not just C), as long as Delphi sticks to using plain C data types in function parameters


A modern shine for the VCL, something like (if not exactly via a purchase/licensing arrangemment) the DevExpress component pack. Including and especially an updated MVC Grid component.


What I don't want is a re-interpretation of existing language construct like what happened to string.


A full preprocessor with (at least) LINE, FILE and MACROS!!!


One thing that I dislike in Delphi is the the way I have to implement a property when using interfaces, I don't know the limitations and why it was designed this way, but this is too "dirty" IMO.

 IMyInterface = interface
   function GetMyProp: Boolean;
   procedure SetMyProp(Value: Boolean);
   property MyProp: Boolean read GetMyProp write SetMyProp; 

Why can't I just write:

 IMyInterface = interface
   property MyProp: Boolean; 

Who cares how the class implements the getter and setter? Oh, ok, you tell me you want a read only property, then:

 IMyInterface = interface
   property MyProp: Boolean readonly; 

Or something like it, this would make my life much less complicated!


I've been using Delphi since the beta before 1.0 and every Win32 version after that and I still consider it to be the best tool for building native Win32 exe-files.

I would like to see:

  • focus kept on Win32 (with 64-bit as a long term goal) instead of .NET
  • improved code-generation (afaik not much has been done here since Delphi 2.0)
  • improve IDE responsiveness. It feels quite large and sluggish compared to VisualStudio.
  • 100% backwards compatibility. I've not used Delphi2009 as much as I wanted to because of problems of converting older code to Unicode.

But in general I'm still a fan of Delphi so the above list should not be seen as complaints!


beautifull !! except and finally in the same block. why not add the += expression ?


SCM integration is a must, tortoise is nice and Embarcadero could officially support it for full integration to the IDE.


Some Delphi Prism features:

  • LINQ
  • contracts
  • futures
  • parallel loops
  • "implies" operator

Reasonable pricing, Turbo edition that costs like a bicycle and not like a car.


Encrypted DataSnap!!!

plz, do Datasnap security!


Expressions as property getters and setters:

property SumAB: Integer read FA + FB;
property FooNumber: Integer read Foo.Number write Foo.Number;

Would be great.


A rooted type system, to make Generics more powerful.


"Beta". Doesn't that mean that no new feature will be added. Only dropping of features. Or have I misunderstood the word "Beta". (rhetorical question)


much more enhanced IDE enviroment. Mopre autocreating and autoupdating classmember functions and procedures and variables (instead of) moving up and down whne adding new class functions etc. There are a lot more to do on intuitive refactoring.


skin support for VCL controls.

this may be not even skin engine itself, but rather ability to create own skin engine and apply it to all controls.

i think this is very important thing for many companies.

so, what i would like to have is and ability to provide skins.

for example, create descendant of certain abstract class (supported by VCL) and apply it or create a class with support for certain interface (supported by VCL) and apply it.

currently to make application good looking we often have to reinvent the wheel by creating those buttons and edits again and again.


a) Multiline strings.

b) Better sintax for closures (a anonymous methods evolution).

c) Mixins.

d) High order functions as methods of arrays and strings:

  MyArray: array of Integer;
  MyArray := [1,6,8,10];
  NewArray := MyArray.map (|x| x+3);

e) Garbage collection.

  A: collected TMemoryStream;
  A := TMemoryStream.Create;
  // using A
end; // automatic A.Free;

f) Contracts, like Delphi Prism.

g) Compiler need to be smarter. Every Delphi programmer lives to make this dumb compiler happy.


Make the VCL Thread safe

  1. Regular Expression
  2. A filtering feature in Code Explorer (a search box as seen in Component List) with sub-string find option to filter Procedures, functions, records and variables etc.
  3. Switch back the help files to WinHelp format. It was much faster to find some help in older Delphi IDEs. At least an option to use older WinHlp files from D7 etc would be nice.
  4. An option to switch off Code Folding (I know the short-cut to do it, but I need an option to switch it off once and for all.)
  5. Improved DB support. (with support for sqllite etc)
  6. STL-like data structure library.

Here is an email I sent to Nick Hodges a couple of weeks ago:

" Hello,

  1. Do you consider having static constructors/destructors in D2010?

I think this is the only thing left to be implemented to have a completely OOP Delphi language. Currently I can not think of a completely OOP oriented implementation of the singleton pattern. I really dislike the initialization, finalization sections. If I have static con(de)structors I would completely remove the need of implementation vars and initialization/finalization sections.

  1. Do you plan to have a OOP style wrappers for the tons of functions already existing. For example I make static classes like TFile, TPath, TString to wrap functions like FileExists as TFile.Exists()
  2. Do you plan to introduce attributes like in C# and Java. I think you already have some partial implementation.
  3. Do you plan having Garbage Collector?I know there are some patterns for reference counted objects but I would prefer having a GC class and a global compiler switch {$GC ON/OFF}
  4. Do you plan to make the binary .cds file format described. I really need to read such files in C# and currently I can?t since the file format is not described anywhere. I know I can export to .xml and than process it but this is not suitable for my purposes.
  5. Do you plan SQLite driver support?
  6. Any plans for native Mac OSX support. You did it for Linux and Mac OSX is just a kinda Unix and its market share is growing. Believe me if there is Delphi 7 for MacOS everybody would love it. XCode simply sucks.

I think if you do those 7 things in the next 5 years I won?t be migrating to .NET 10.0 soon and will continue to use Delphi as primary development environment.

Last word: Great stuff!! Delphi 2009 is finally stable after the a bit ?experimental? Delphi 8 and 2006. You know why everybody loves Delphi 7 ? simply because it was stable.

I would prefer D2010 to be more stable even compared to D2009 instead of having 64bit support or parallelism or other ?fancy? stuff. "

Still haven't received answer though.


IDE Intelligence

64bit compiler

Language features e.g. try/except/finally More generics ...


to make Delphi the first language :

  • cross compiler (only with header for linux and macosx 32/64bit)
  • vcl -> gtk or qt to build (form) application without lose past compatibility
  • full integration with SOAP and possibility to create a stand alone app/service as WebServices

is possible?

... and why not, do you know zkoss , a framework like that to build WebApplications with indy.. was fabuluos


some cryptography support

SHA,DES,AES, etc They are very useful

plus a way to digitally sign files


A small thing... but it sure would be nice if they implemented structural highlighting, ala Castalia. That is a real lifesaver when you are working on nightmare 1000-line functions. In fact, they should just buy Castalia and include most of it's functionality natively (including the relevant options to turn it off).


Better compatibility with legacy (ansi) sourcecode:

The ability to define on a per-unit basis if the default string/char types should be Ansistring or Unicodestring. The lack of this is my #1 problem.


hmmm i'd like to see:

  • 64bit Compiler
  • Crosscompiling to other OS... Maybe OSX.
  • Windows 7 features in VCL
  • a Standard Version without any database stuff or a smaller version which is more affortable and not so pricy, but with third party components support

Cheers, murphy

  • CASE on non-ordinal types
  • 64 bit compiler
  • profiler
  • Inline variable declaration

a CONST keyword which serves some purpose (namely : tagging as "const" an object or a pointer would prevent changing the object/pointee's content)


Integrated support in the IDE for information in the xx_MemoryManager_EventLog.txt file that the debug version of FastMM generates. It would be nice to be able to jump to the lines in the source code where memory leaks are occurring.


cross compilation to other platforms (osx, linux)

  • Linux
  • Firebird Support
  • Windows7 64 bit support
  • Easy IDE (Like Delphi7 )
  • Faster (Like Delphi 7 )
  • Unicode support for CDS Filter ( Midas )
  • Improvements on Database Controls ( for example improved DBGrid )

64 bit compiler !


64 bit compiler and cross platform compiling


A really - really - effective means of moving backward and forward through a chain of declarations. The existing solution works well if the code compiles, and I've evidence that under D2009 it is worse than D7. I'd like a parser / text search mechanism to do the lookup even on code under construction. Bri


Support in the delphi framework for Microsoft Management console(MMC) snap-ins.

It is an important standard and been around for over 10 years


undo / redo in design time and stable IDE only

  • When I am in a block of code (in a begin/end pair or try finally or repeat until or case structure or ..?) I would like that whole block to be highlighted.

  • Dock non-visual components in some kind of tray rather than in the Form because they get in the way.

  • I would like to make "application level" components which only show up for certain projects and are targeted to a set of projects. There are parts of large applications that can be made into components - but those components are only relavant to that project or set of projects. I do not make components because it is too time consuming. I would like an easy way to create them for a given project. Maybe like a component bucket for a project where I can create new components but I do not have to install them - they become available to the current project.


Three compilers

  • first from Delphi 7 - you can make programs for Windows 98, you can develope old programs
  • second from Delphi 2009 - with Unicode
  • third for 64 bits programs
  • Win64 support
  • Bold released with full source so we can move our apps up from Delphi 2006 (where they are stuck, cause Bold has not been updated for newer versions of Delphi)

Better support for projects that can be restored everywhere.

IOW proper support for relative paths and base paths in Delphi and all its tools.


Cross platform for server side code. Not interested in another CLX disaster, I just want to be able to run app servers on other platforms.

Optional garbage collection like Objective-C has would also be nice.


Field overriding. Imagine the following scenario, based on an issue I ran into while building a sprite-based game engine:

  TSpriteEngine = class; //generic 3rd party sprite engine

  TSprite = class(TObject) //generic 3rd party sprite
    FParent: TSpriteEngine;

  TSpriteEngine = class(TObject)
    FList: array of TSprite;

  (And now, in another unit:)

  TGameEngine = class;  //my own sprite engine with extra features

  TGameSprite = class(TSprite)

  TGameEngine = class(TSpriteEngine)

Now, TGameEngine and TGameSprite have special new functionality that only work with each other, and not with the base types. But the parent/child fields are defined as the base types and can't be changed, which means that any type safety has to be implemented at runtime with is/as checks, and any uses of the parent/child references that need the extra functionality have to be typecasted.

Why not make this valid syntax?

  TGameSprite = class(TSprite)
    FParent: TGameEngine; override;

  TGameEngine = class(TSpriteEngine)
    FList: array of TGameSprite; override;

Adding the override directive to a field declaration would allow you to redefine a field inherited from an ancestor class as a derived type of the original. It would have to meet type safety checks at compile-time, (if you override FObject: X as FObject: Y, it would only compile if "Y is X;",) and the compiler would not create a new data member, but be instructed to treat the existing one as the derived type instead of the base type when using the derived class.

Improved type safety and cleaner code (less spurious typecasts) without having to add a new keyword. I think it would be a good idea. Anyone else like it?


Due to the IDE stability issues I haven't upgraded from D7 yet so I might be after something that's been rendered moot by generics:

I would like to be able to redefine a routine in a descendant without actually using any code. This would in effect be a typecast. Too often I've had to write routines that simply typecast a variable and call the inherited method.


Consistant Memory Management for vairous applications: exe application, dll application,service application.....,we don't want to use build with runtime packages any more!!!!!!!!!!!!!!!!!!!!!

  • Annotations (like C# and Java, and Delphi.NET?)

  • RTTI for constructors - this would allow to create constructor-based dependency injection (until now, only property-based DI is possible)

  • namespaces/packages (like C# and Java and Delphi.NET)

  • SOAP 1.2 support

  • JSON based object serialization


  • include the XML Databinding Wizard in Professional edition
  1. Vastly improved linker error messages.
  2. Support for the Microsoft object file format (yes, I know that's very hard, but that way we wouldn't depend on C++ Builder for static linkage.)

Let them bring back the VCL.NET personality in a modernized version and ditch Prism. That'd make me really happy :)


A just in all aspects working Delphi -> C++Builder system. The HPP generator of RAD Studio 2007 is so crappy in basics - it is still nearly unusable. Using any new language feature of Delphi upsets the HPP generator completly. There are so many QC entries, but none resolved. If you add new features, than support it in the whole product - you are advertising with the C++Builder usage of Delphi code - but up to now, it is not.

So get this clear and working!


My top two items would be:

(1) 64-bit Compiler

(2) STL-equivalent


Bold support.... We are stuck on Delphi 2006 until Bold is updated...


Some built in framework's - like MVC or MVP

With a lot of supporting libraries


what about delphi compiler for embedded devices?


A built in switch to generate compiled obsfucation into the executable, like what is done with ExeCryptor.

procedure TForm1.ExampleMethod;
  sBuffer: string;
  sBuffer := '';

   MyPassword := Edit1.Text + GenerateGUID();

  sBuffer := 'Method Done';

Code obsfucation would get added during Delphi compile.


class explorer for c++


We need implementation in Delphi functionality like in C with frendly classes - OOP is good but object is not enought for object model with big object quantity. You need to find way to implement entity of LAYER in around world in delphi code. It mean that classes are more integrated inside the layer and add some rules to interoperation between layers of objects(classes) (extend C frendship);

  1. Document the DCU format.
  2. Make DCU Format compatible with old versions of delphi.

I have used many RAD based IDE but after trying Delphi4PHP I really liked the way in which forms (HTML web pages) are implemented.

I wish that in Delphi we get a form which have a surface similar to a HTML page (as implemented in Delphi4PHP).

This would make designing forms with dynamic contents truly dynamic and easy. Imagine being able to show problems and text description of that problem in a controls content in data entry form right next to the control without having to put hidden labels next to each control and then making them visible and again hiding them.

Again Imagine the easy with which we can change the look and feel along with locations of controls (on a form) of the form just by making changes to an external CSS like file without having to recompiling the software!


Nilable types like the Nullable types in C# 2.0. I don't like the Variant since it allows a lot more than int/null values t be written in a int?


My wish list would be (prioritized):

  • More stable IDE, I've experienced several exception windows from the compiler at seemingly random moments. I've seen this in both 2006, 2007 and 2009 releases.
  • More modern compiler, honestly still in the 2009 version the most advanced CPU the compiler can optimize for is the Pentium Pro.
  • 64 Bit support, this is something I've waited for, and really looking forward to. As a side note, it may even force them to add some improvements to the compiler.
  • Cross platform version of VCL.... Now that would rock.
  • One thing that is very unlikely to get through. (and only for the C++ compiler really) standardize the VCL more, since my confidence in Codegear surviving for much longer (at least the C++ Builder product) is at a historical low. It would be fantastic using i.e. the Intel C++ Compiler with my C++ Builder Project.
  • Add a Webkit (or Gecko) component directly just like the TWebbrowser/TCPPWebbrowser, much like what you get in Qt.

Though I doubt we will see any of the points, except for the 64 bit support. Which by the way, would be a much welcomed addition.


Cross platform compiler


Fix the Object Inspector - Please! It's been broken for so long now. When you elect to Arrange by Name it is very buggy!

It s a small thing but honestly, why has it remained broken for so long. I always opt for Arrange by Name and it is just a pain when scrolling. Seems like a refresh problem.


i like to have aliases in "with"-statements.


I would like that Properties like .Caption and .Hint etc. can be replaced by a resource-String variable for better translation.


1: Native Decimal type, decimal arithmetic, see QC report #68381 - this could replace FmtBCD.

2: Multiple main/foreground threads: each with it's own message loop and form handling; the application would exit when all foreground threads are finished - extremely useful when you want to develop a multitask application like Firefox or Office (the latter doesn't support this functionality either).

3: Complete documentation

4: Better interface RTTI, as in QC report #46581

5: Access to the syntax tree in IDE experts, for custom code formatters and stuff.


My wishlist:

  • Stable IDE;
  • A thorough review of QC reports;
  • Cross-platform compilation support;
  • Compiler optimizations for modern CPUs;
  • 64-bit compiler;
  • BASM function inlining;
  • Revised RTTI that supports additional property data;
  • SVN integration.
  • Stability
  • Stability
  • Stability
  • x64-compiler
  • Official x64-support for the environment (not wow64)

It would be great to have a code beautifier. There exists some from 3rd party even for free, but I would expect this feature in each good development tool.


Get sources of BDE...


A working version of Kylix.

In this day and age, I guess that means a baked-in version of Mono with full support.


Move dfm into pas file like in c#. Stable IDE