Launch a terminal program but have it continue to run once terminal is closed - Lazarus or Delphi

Question

Pre-amble: I use Lazarus 1.2.6 and Freepascal 2.6.4 on Windows 7 and my solution must be based on that - not C or C++. I could use Delphi though, if something similar exists for that.

Problem: I wish to create a small program that is ideally launched from the command line, but then just runs in the background without the need for the console application to be open visibly.

I'm trying to work out how best to achieve it.

I read this link and this link and this C based example and this Linux example but as one user points out "if you don't want a console application, don't make one", which begs the question of what are the other ways? If you don't want a GUI, and you don't want a console, I assume there's another way to create a silent program, then launch it, and then just have it run in the background? Preseumbly as a service or some such?

Or, the other way that occured to me is to create a Library (which generates a DLL when compiled of course) that contains my programs functions, export those functions at the end of the DLL, then call them from a seperate terminal application which, I assume, I could then close but the functions that are called from the DLL might continue to run? In other words - two programs - one terminal program to launch the other non-visible program and then close the launching program? Is that possible or recommended?

Answer 1

I've written about this topic before, but not specifically with regard to Delphi or Free Pascal.

Use the {$APPTYPE GUI} directive to tell the compiler to generate a GUI application rather than a console application. You'd generally put it near the top of your main project file, where the program statement is. When you use that directive, the program will neither inherit the console of its parent nor create a new console. If you don't actually want a GUI, then don't display any windows; if you have a console application, the OS creates the console for you automatically because "consoleness" is a property of the EXE file.

Using a separate program and DLL won't have the effect you're looking for. As you already know, functions block the caller until they return. Therefore, when the host program calls your DLL function, it will wait until it returns before exiting. A DLL is not a separate program; it can't run without its host. (Using a separate thread won't work, either, because when the main thread terminates the program, it destroys all other threads whether they're finished or not.)

Answer 2

If you don't want a console application, don't make one.

That sounds like something that I might have said!! And yes, that's the way to deal with this. When one console application starts another one, the parent process blocks until the child completes. You can arrange for the child process to break away from its parent's console, but then you'll just end up with two consoles.

What you really want to do is create a process that targets the GUI subsystem rather than the console subsystem. In other words, you don't want a console application, so don't make one. Make a GUI application instead.

Now, a GUI application doesn't mean that you have to show GUI. There's no compunction to do so. You have a process to break away, execute in the background, not attach to the parent console. That's an application that targets the GUI subsystem but does not show any GUI.

For example, this program targets the GUI subsystem, but shows no GUI. It's rather useless because it blocks indefinitely. However, you'd replace that with your background task.

program project1;
{$apptype gui}
uses
  windows;
begin
  Sleep(INFINITE);
end.

Answer 3

With Lazarus it is very simple. Just write small launcher program:

program project1;

uses
    Process;

var
    p: TProcess;
begin
    p := TProcess.Create(nil);
    try
        p.ShowWindow := swoHIDE; // To hide your console app
        //p.ShowWindow := swoShowNormal; // To show your console app
        p.Options := [poNewConsole];
        p.CommandLine := 'cmd'; // Change to your app name
        p.Execute;
        Writeln('Programm launched.');
    finally
        p.Free;
    end;
end.  

Actually, it is not Lazarus but pure FPC program.

Answer 4

Assuming you're only using this program under Windows, you can simply call FreeConsole from the Windows API:

FreeConsole function

Detaches the calling process from its console.

For example this simple program:

program project1;
uses
  sysutils, windows;
begin
  FreeConsole;
  while(true) do
    sleep(50);
end.

Can be launched from the explorer or from cmd and runs infinitely without showing its own console. When launched from another console, it continues running even if the other cmd instance is closed.