Shop Learn
Catalina — Parallax Forums

Catalina

RossHRossH Posts: 4,730
edited 2021-10-14 21:14 in Propeller 2
I have just added the release version of Catalina 4.9 to SourceForge. This release is for both Windows and Linux.

The main purpose of this release is to fix up a lot of issues with Catalina's Propeller 1 support. I have been concentrating almost entirely on the Propeller 2 recently, and not realized that I had broken some of the Propeller 1 functionality. I have also taken the opportunity to do a major clean up of the documentation and demo programs.

Here is an extract from the README.TXT file discussing the new functionality. This functionality is mainly concerned with the new integration between Catalina, Geany and the make utility (which is now included in the release):
RELEASE 4.9

New Functionality
-----------------

1. There has been a major rewrite of all the demo programs and build scripts 
   in the demos directory and all its subdirectories. Makefiles are now
   provided for all the demo programs, which can be used either manually (i.e.
   by invoking 'make' on the command line) or via the Catalina Geany IDE. All
   platforms are supported by these new Makefiles except for the MORPHEUS and
   TRIBLADEPROP platforms (which still use the old batch scripts).  To use the 
   Makefiles on Windows, this means you need to have a version of 'make' and
   some core utilities that it needs installed. The Windows installer can 
   install these for you if you do not already have them (e.g you don't 
   already have MinGW installed), or you can download them from here:

       http://gnuwin32.sourceforge.net/packages/make.htm
       http://gnuwin32.sourceforge.net/packages/coreutils.htm

   The recommended version of make to use with Catalina is 3.81. The 
   recommended version of the core utilities is 5.3.0.

   Note that Catalina can still be used as a command-line compiler without
   installing 'make', and even Catalina Geany can still be used without it 
   to compile simple programs. But to build more complex examples (such as 
   the Catalyst demos) or use the various build_all scripts, a version of 
   'make' is required.

   Most of the 'build_all' scripts have all been rewritten to just invoke 
   'make' internally, but other than that should work similarly to how they 
   worked in previous releases. So there are now four different methods you 
   can use to make the demo programs and your own C programs.

   For instance, in the demos directory, there are now four ways to compile 
   the hello_world.c program ...

   a) Manually, by invoking catalina yourself on the command line with 
      appropriate command-line options - e.g:

         catalina hello_world.c -lci

      You can define Catalina symbols on the command line to specify options
      for your compilation, or else use the CATALINA_DEFINE environment 
      variable. For example, the following will give identical results:

         catalina hello_world.c -lci -C C3 -C COMPACT -C HIRES_VGA

      and (on Windows)

         set CATALINA_DEFINE=C3 COMPACT HIRES_VGA
         catalina hello_world.c -lci

     or (on Linux)

         export CATALINA_DEFINE="C3 COMPACT HIRES_VGA"
         catalina hello_world.c -lci

      The advantage of using the CATALINA_DEFINE environment variable is that 
      if you are working with a single Propeller platform, you don't need to 
      specify this in every compilation command. Note that you don't use the
      -C command line switch when defining symbols using CATALINA_DEFINE.

   b) Using 'make'. For all the Makefiles provided in the demo directory and
      its subdirectories, you can make either a single target, or all the 
      targets specfied in the Makefile - e.g:

         make hello_world

      or

         make all

      Note: if you see a message like the following:

         make: Nothing to be done for `hello_world'

      then it means that 'make' did nothing because the program binary
      already exists and is up to date. You can force 'make' to rebuild
      the program either by first saying 'make clean', or by invoking 'make' 
      with the -B command line option - e.g:

         make -B hello_world

      Note that compiling with 'make', like all Catalina compilations, will
      use any Catalina symbols defined in the CATALINA_DEFINE environment
      variable. This allows generic Makefiles to be written more easily. 
      All the Makefiles provided as demos use the 'catalina_env' command to
      print out all Catalina environment variables before they build the
      programs to remind you what is specified in CATALINA_DEFINE.

   c) Using the build_all scripts, with or without appropriate Catalina 
      symbols specified to the command - e.g :

         build_all 

      or

         build_all P2_EVAL NATIVE VT100 CR_ON_LF

      The build_all scripts are now wrappers around 'make'. They don't work
      exactly the same way they did in previous releases, partly because the
      demo directories have been restructured, but they still accept command
      line parameters to specify the Catalina symbols to define for the
      build. By convention, the first parameter is always the platform, and
      Propeller 2 platforms should always start with "P2" (e.g. P2_EVAL, 
      P2_EDGE, P2D2 etc).

      The build scripts, like all Catalina compilations, will use any Catalina
      symbols defined in the CATALINA_DEFINE environment variable. Note that 
      if you specify conflicting symbols as parameters to the build_all script, 
      it will print a message about the conflict and not compile any programs.

   d) Using Geany. You can specify a Geany project on the command line, or 
      just start Geany with no project specified (which will start Geany with 
      whatever project was last loaded) and then manually load the project 
      file in Geany - e.g:

         catalina_geany hello_world

      or

         catalina_geany

      Then, in Geany you have two sets of commands on the Build menu. Note 
      that in Geany the build menu is determined by the type of file you 
      have currently selected. You must have a C file (i.e. a file with a 
      “.c” extension) open and currently selected to see the C Build commands.

      The first set are the simple build commands:

        Compile     - compile the current file only and produce an object file.

        Build       - compile the current file only and link it to produce an 
                      executable.

        Compile All - compile ALL the C files in the current directory to 
                      separate object files, but do not link them.

        Link        - link ALL the object file in the current file to produce 
                      an executable. The executable will be named for the
                      current file.

        Clean       - remove all binary, object, listing and executable files
                      in the current directory (similar to 'make clean').

      These commands are suitable for C programs that consist of a single
      C file, or when all the C files in the directory belong to the same
      project and there are no dependencies between them, and no other
      steps required except compiling and linking.

      After the simple build commands on the Build menu, you will see the
      two 'make' build commands:

        Make                 - Make the current project using the Makefile
                               in the current directory - i.e. invoke 'make'
                               specifying the current project as the target.

        Make (Custom Target) - Make a custom target. Geany will prompt for
                               the target name, which can be the special
                               targets 'clean' or 'all'.

   Like all Catalina compilations, Geany will use any Catalina symbols defined
   in the CATALINA_DEFINE environment variable. You can set this variable to
   specify to your platform and memory model. For instance, on Windows you 
   might say:

         set CATALINA_DEFINE=P2_EVAL COMPACT

   On Linux, the syntax to set environment variables is different. You might 
   instead say:

         export CATALINA_DEFINE="P2_EVAL COMPACT"

   Then, no matter which method you use, your programs will be compiled as
   if you had specified -C P2_EVAL -C COMPACT on the command line. Note that 
   if you specify conflicting symbols as parameters to the build_all script, 
   it will print a message about the conflict and not compile any programs.

   Catalina Geany has the ability to specify options to its build commands.
   You can specify these in the Project Properties menu item. Typically,
   the options would include libraries, optimization levels, and any
   Catalina symbols you might want to define. For instance, the options
   specified for "hello_world" might be as follows (multiple lines are 
   acceptable here):

      -p2
      -lci
      -O5
      -C NO_REBOOT

    This means compile for the Propeller 2, use the integer version of the 
    standard C library, use optimization level 5, and define the Catalina 
    symbol NO_REBOOT, which prevents the program from rebooting the Propeller
    on exit from the main function (which in some cases might prevent all
    the output from being sent to the terminal before the Propeller reboots).

    These options are used by the simple build commands. In order to make 
    them accessible to the 'make' commands, the Make command actually used 
    is as follows:

       make "%n" CATALINA_OPTIONS="%o" 

    This allows Geany to pass the options defined for the project to the 
    project Makefile using the variable CATALINA_OPTIONS. The Makefiles 
    provided for all the demo programs check whether CATALINA_OPTIONS have 
    been passed, and try and use sensible default options if not. So even if 
    you are using 'make' stand-alone, it is not usually necessary to specify 
    options on the command line. This is what allows you to say (for example)
    just:

       make hello_world

    instead of having to say:

       make hello_world CATALINA_OPTIONS="-lci -C NO_REBOOT"

    Like the build_all scripts in the previous releases, all the Makefiles 
    provided in the demos folder attempt to determine automatically if you
    are compiling for a Propeller 1 or 2, based on either the suffix, or
    (if no suffix is specified) then on whether the substring "P2" appears 
    in any of the Catalina symbols defined in CATALINA_DEFINE or if "-p2"
    appears in CATALINA_OPTIONS. This means you do not generally have to 
    explicitly add the -p2 option unless you are compiling for the default 
    platform (and are therefore not specifying any specific platform).

    The Makefiles in the demo folders contain default rules that know
    how to make .bin, .binary and .eeprom executables. So, for example,
    if hello_world.c exists in the folder, you can simply say:

       make hello_world.bin
       make hello_world.binary
       make hello_world.eeprom

    to build the executable with default options (which can also be specified
    in the Makefile) and get the expected result. You can use the Makefile in 
    the main demo directory as a template for your own Makefiles.

    Note that 'make' uses only the file date/time to determine if the
    executable needs to be remade, and is not aware of any changes you may
    make either to CATALINA_DEFINE or to Geany build options - so in some
    cases you need to use 'make clean' to remove old executables, or add the
    -B option to 'make' to force it to rebuild the executable. Or you can
    specify clean as your first target - e.g: 

       make clean hello_world

2. A new build command option has been added to the Catalina version of Geany.
   Now as part of a project build command, you can specify %n which will be
   replaced with the name of the project. By default, this option is now added
   to the 'make' build command which is now:

      make "%n" CATALINA_OPTIONS="%o" 

   The purpose of this is to allow a single Makefile to be used to make 
   multiple projects with sources in the same directory. This capability is 
   used in many of the Catalina demo folders, rather than having to have a 
   separate subdirectory (and a separate Makefile) for each individual demo 
   program. Instead, the Makefile can simply have multiple targets, named for 
   each project that uses the Makefile.

3. Catalina Geany has been modified to allow relative file paths. This
   allows geany project files to be independent of where they are installed.
   This means, for example, that you can more easily copy all or part of the 
   demos directory to another location to build the example programs. You no 
   longer need to build them in place in the Catalina program folder. 
   Note that in Geany you can specify "./" (without the quotation markes) as 
   your project base path in the project properties. This applies on both 
   Linux and Windows (even though Windows doesn't normally use "/" as a path 
   separator) - it is not really a path specifier, it is a signal to Geany 
   to use the path to the Geany project file as the base directory for the 
   project.

4. A new set of definitions has been added for P2_EDGE in the configuration
   file catalina_platforms.inc in the target_p2 folder. Currently, all the
   values defined are the same as the P2_EVAL board, but they can be edited 
   if desired.

EDIT: There is now an errata file for release 4.9, to workaround the problem of Catalina Geany crashing on startup on some Windows system. The file is attached to this post. Apply this by simply unzipping this over your Catalina installation. Does not affect Linux installations.



Ross.
«1

Comments

  • RossHRossH Posts: 4,730
    edited 2020-10-03 22:36
    Catalina 4.5 has been superseded by release 4.6. See the previous post for details.
  • RossHRossH Posts: 4,730
    Catalina 4.6 has been released. See the top post for details.
  • RaymanRayman Posts: 12,207
    @RossH Thanks for keeping Catalina going. It's nice to have options...

    I just installed the latest version to see if it could run this MicroMax Chess code...

    It compiles and run, but just like FlexC, it hangs if you hit enter when it is supposed to look for a move.
    You can manually move pieces by entering moves like "e2e4", but also just like FlexC, there is something wrong with the black pawns... They don't move, for example.

    Anyway, don't expect you to do anything about it, just letting you know I'm testing out Catalina.

    This code was designed to use as few a characters as possible, which seems very silly to me... I imagine why that is why compilers might have a hard time with it...
  • RaymanRayman Posts: 12,207
    edited 2020-10-10 22:26
    This chess code seems to work, except that the function GetMillisecs() needs fixing because I hacked it to make it compile.
    The interface asks how many seconds to give computer. If you say "0", it moves right away. If you say "1", it thinks longer that I could wait for...

    Also, it can't find the opening book file even though I put it on the uSD card of the Eval board...

    I did the compile and load like this:
    catalina NGplay_61.c -p2 -lc -C P2_EVAL -C NATIVE
    payload -i -z -b230400 NGplay_61.bin
    
    c
    c
  • RossHRossH Posts: 4,730
    Rayman wrote: »
    @RossH Thanks for keeping Catalina going. It's nice to have options...

    I just installed the latest version to see if it could run this MicroMax Chess code...

    It compiles and run, but just like FlexC, it hangs if you hit enter when it is supposed to look for a move.
    You can manually move pieces by entering moves like "e2e4", but also just like FlexC, there is something wrong with the black pawns... They don't move, for example.

    Anyway, don't expect you to do anything about it, just letting you know I'm testing out Catalina.

    This code was designed to use as few a characters as possible, which seems very silly to me... I imagine why that is why compilers might have a hard time with it...

    Seems to work ok for me. But I must admit I only played a few moves, because each move takes a looooonnnnnggg time!

    What are you running it on, and what command did you use? I ran it on a P2, and used the command:
    catalina -p2 micromax.c -lci -ltiny -C P2_EVAL -C TTY -C NATIVE -C NO_FLOAT
    
  • RossHRossH Posts: 4,730
    Rayman wrote: »
    This chess code seems to work, except that the function GetMillisecs() needs fixing because I hacked it to make it compile.
    The interface asks how many seconds to give computer. If you say "0", it moves right away. If you say "1", it thinks longer that I could wait for...

    Also, it can't find the opening book file even though I put it on the uSD card of the Eval board...

    I did the compile and load like this:
    catalina NGplay_61.c -p2 -lc -C P2_EVAL -C NATIVE
    payload -i -z -b230400 NGplay_61.bin
    

    I haven't looked at the code, but to use the SD Card you need to use -lcx instead of -lc
  • RossHRossH Posts: 4,730
    Hi @Rayman

    I was interested as to why the MicroMax chess program is so slow, so I did some measurements on it. I only did a couple of runs, but the reason becomes clear almost immediately - most of the work is done by one function (D), which is recursive. This very complex function gets called anywhere between 200,000 and 500,000 times while searching for the best move, and it recurses to a depth of 25 or so calls.

    I think the author was concentrating on program size, not speed! :)

    Ross.
  • RaymanRayman Posts: 12,207
    @RossH i think you are right. Although it seems to have been ported to microcontrollers. The code is very obtuse though. I think I like the look of ngplay better.
  • RaymanRayman Posts: 12,207
    edited 2020-11-09 14:35
    I tried out MicroMax again after seeing it in Gameduino...

    This code seems to work with Catalina. Rigged for computer vs computer.

    Had to bypass the millis() function though.
    In FlexProp, there is now _getms().
    Not sure this is really used by the chess engine itself, so I didn't bother to fix it.

    BTW: Is there a way to escape from the payload terminal and get back to command line?
  • RossHRossH Posts: 4,730
    Rayman wrote: »
    BTW: Is there a way to escape from the payload terminal and get back to command line?

    CTRL-D
  • RossHRossH Posts: 4,730

    Catalina 4.7 has been released (currently, Windows only). See the first post in this thread for details.

  • RaymanRayman Posts: 12,207

    Just installed... Windows complained a lot, but was able to get it to install.

    Seem to be missing the "Catalina Command Line" shortcut in the start menu. But, I found it in the install folder.

  • RaymanRayman Posts: 12,207

    It does still build a chess program I tried before with Catalina, NGplay_61.c, so that's good.

    Tried to compile lvgl (https://github.com/lvgl/lvgl), but it's not finding the include files...
    There are about a thousand include files...
    Catalina does not seem to be finding them.
    I'm sure I'm doing something wrong...

    This is asking a lot, but if you want to see what I'm looking at...
    The build.bat file in the attached tries to compile lvgl_test1.c
    It looks like it finds include files in the current directory, but not in the \src directory tree...

  • RossHRossH Posts: 4,730

    Hi Rayman

    Will have a look tomorrow.

    rossh

  • RossHRossH Posts: 4,730
    edited 2021-09-05 23:52

    @Rayman said:

    Tried to compile lvgl (https://github.com/lvgl/lvgl), but it's not finding the include files...
    There are about a thousand include files...
    Catalina does not seem to be finding them.
    I'm sure I'm doing something wrong...

    There is something wrong with your directory structure. Here is first error message I get, with an example of the problem:

    cpp: ./lv_conf_internal.h:41 ./src/misc/lv_log.h:16 ./lvgl.h:25 lvgl_test1.c:3 Could not find include file "../../lv_conf.h"

    So, decoding that:

    lvgl_test1.c includes ./lvgl.h at line 3
    ./lvgl.h includes ./src/misc/lv_log.h at line 25
    ./src/misc/lv_log.h includes ./lv_conf_internal.h at line 16
    ./lv_conf_internal.h includes ../../lv_conf.h at line 41

    But from the location you are compiling lvgl_test1.c there is no ../../lv_conf.h - however, there is one at ./lv_conf.h

    rossh

  • RossHRossH Posts: 4,730

    @Rayman said:
    Just installed... Windows complained a lot, but was able to get it to install.

    Seem to be missing the "Catalina Command Line" shortcut in the start menu. But, I found it in the install folder.

    Odd. Works ok for me. What version of Windows are you using?

    rossh

  • RaymanRayman Posts: 12,207

    @RossH said:

    @Rayman said:
    Just installed... Windows complained a lot, but was able to get it to install.

    Seem to be missing the "Catalina Command Line" shortcut in the start menu. But, I found it in the install folder.

    Odd. Works ok for me. What version of Windows are you using?

    rossh

    Latest Win10. I still had the last version installed though. Maybe that messed it up somehow…

  • RaymanRayman Posts: 12,207

    Thanks for looking at the code issue. Looks like an easy fix.

  • RossHRossH Posts: 4,730

    I have updated payload to allow it to be used to program FLASH RAM on the P2 without needing to reset the microswitches on the P2_EVAL board. This required a modification to the Propeller version detection code (basically, you can now override it and manually specify your Propeller version). This update allows payload to correctly use the 100ms serial window on the Propeller 2.

    Attached is a zip file containing the new version of payload and the updated README_P2.TXT file. This version will be included in Catalina 4.7 when I have finished testing the current beta release. Here is an extract from the updated README_P2.TXT file:

    There is also a a payload-based utility that can program the FLASH RAM on the
    P2_EVAL board:

    flash_payload program.bin [ other payload options ]

    e.g:

    flash_payload othello.bin -b230400 -z -i

    Note that you must have the microswitches on the P2_EVAL PCB set correctly to
    program the FLASH. Here is one way to do it:

    FLASH set to ON
    P59^ set to ON
    P59v set to OFF

    Then, execute the flash_payload command, and once all the LEDs have gone out
    (which indicates the FLASH programming has completed) set the P59^ microswitch
    to OFF and reset the P2 to execute the loaded program from FLASH.

    Another way to do this is possible, which does not require microswitch changes.
    However, this method only works if you override payload's normal autodection
    of whether it is talking to a Propeller 1 or a Propeller 2 using the -o option.
    Set the microswitches as follows:

    FLASH set to ON
    P59^ set to OFF
    P59v set to OFF

    Now, by executing the flash_payload command with the -o2 option, you can load
    the FLASH RAM and then execute the program from FLASH in one command without
    needing to change any of the microswiches. For example:

    flash_payload othello.bin -b230400 -o2 -i

    rossh

  • RossHRossH Posts: 4,730

    I have just uploaded a validated (i.e. non-beta) release of Catalina 4.7 to sourceforge. This release is for both Linux and Windows. There are a few changes from the beta release:

    • NATIVE is now the default mode for the Propeller 2.
    • there is a new version of the payload loader, with improved support for FLASH RAM on the Propeller 2.
    • Code::Blocks is no longer supported on Linux (it remains supported on Windows).

    See the first post in this thread for more details.

    rossh

  • RossHRossH Posts: 4,730

    I've just uploaded Catalina 4.8 to Sourceforge. There aren't many differences to 4.7, so I've also uploaded some small "patch" files to the errata directory (https://sourceforge.net/projects/catalina-c/files/errata/) which you can use to upgrade an existing 4.7 release to 4.8 without having to download and install the whole new release.

    The differences are very minor (mostly some missing documentation updates and an update to the inline PASM function).

    Here is an extract from the README.TXT:

    RELEASE 4.8

    1. Updates to the reference manuals and the command summaries to include the
      changes made to payload in release 4.7.

    2. A bug introduced in release 4.7 when making NATIVE the default memory
      model on the P2 has been fixed.

    3. The definition of the PASM() function (used to include inline PASM in C
      code) has been modified to indicate it can return an int rather than a void.
      This prevents Catalina from overwriting return values (i.e. the value
      present in r0 when the PASM code finishes execution). The new definition is:

      extern int PASM(const char *code);

      This should not make any difference to existing code that does not use the
      return value of the PASM function. New PASM example program called
      test_inline_pasm_3.c and test_inline_pasm_4.c have been added to the
      examples in the demos\spinc folder to illustrate the use of the return value.

    4. Updated the build_all scripts in the demos\spinc folder to only build demo
      programs appropriate to the propeller type (i.e. 1 or 2).

    5. The file flash_led.obj was missing from the demos\spinc folder.

    The bug mentioned in point 2 was very minor and is unlikely to have affected anyone's C programs except mine (the compiler was defining both __CATALINA_NATIVE and __CATALINA_TINY in some cases when it should have defined just __CATALINA_NATIVE).

    Ross.

  • RossHRossH Posts: 4,730

    I have no plans for another release of Catalina just yet, but I have a question ...

    I recently dropped support for the Code::Blocks IDE under Linux (I can no longer get it to compile), and I expect to do so in Windows soon (same reason - it is becoming almost impossible to compile). Also, Code::Blocks is far too complex for the type of projects we typically build on the Propeller.

    The Catalina Geany IDE (which will remain supported) is much simpler and easier to use.

    However, one advantage Code:Blocks did have is that you didn't have to have a make utility installed - it has an equivalent built in. Geany does not have this - it can build simple projects very easily, but complex projects must use an external Makefile, and therefore (on Windows) this requires you to also install a version of make.

    So ... here is the question ...

    Would it be ok to assume Windows users can install and use a version of make (e.g. from http://gnuwin32.sourceforge.net/packages/make.htm) to build all the example programs and demos? Doing so would mean that I would no longer have to support different batch scripts on Windows and Linux - I could just use a common Makefile.

    Obviously, I am thinking 'yes' because it would save me quite a lot of work - but I am interested in hearing other opinions before I finally decide.

    Rossh

    P.S. Also, just an early warning - the next version of Catalina will probably remove the -F compiler option, which allowed the binary output to be produced in different formats (e.g. Motorola S record or Intel Hex format). You will of course still be able to generate the standard Parallax formats - .bin on the P2, or .binary or .eeprom on the P1. If anyone still needs this capability (I can't even remember now who originally requested it) then the srecord utility (which is what -F invokes) has a stand-alone version you can use to do the same job. It no longer seems necessary to have this capability embedded within Catalina. Again, comments welcome.

    Ross.

  • Would CodeLite be a replacement worth looking at? I think it's a maintained fork of Code::Blocks. Otherwise, is there any accessible/reusable portion of LccWin32?

  • RossHRossH Posts: 4,730

    @Circuitsoft said:
    Would CodeLite be a replacement worth looking at? I think it's a maintained fork of Code::Blocks. Otherwise, is there any accessible/reusable portion of LccWin32?

    Sorry, just saw this - been busy. I think CodeLite would have the same compilation nightmares as Code::Blocks, since it also uses wxWidgets (which was Code::Blocks downfall).

    Geany does everything I need, is much simpler to modify, build and use, so I have decided to go with that. The only thing missing from Geany on Windows was the lack of a built-in ability to build complex programs (which Code::Blocks had). But since I have now added **make **to do that particular task, this deficiency has been very neatly solved.

    Ross.

  • RossHRossH Posts: 4,730

    All

    I have just released Catalina 4.9. See the first post in this thread for details. It is primarily a Propeller 1 "bug fix" release, but it also adds better integration between Catalina, Geany and make on the Propeller 2.

    I would appreciate feedback on the installation process from Windows users. I have seen some odd initial behavior - basically, on initial install some programs (most notably Geany) seem to crash or not run at all ... then, a few minutes later, everything seems to work fine without further intervention. I am presuming this is some weird new Windows 10 behavior, but every time I try and reproduce it, it just seems to go away by itself before I can figure out what's wrong.

    Ross.

  • RossHRossH Posts: 4,730

    Annoyingly, I just found a Catalina bug. It only affects Propeller 1 programs that use the PROPTERMINAL HMI option.

    Attached is a small errata file.

  • RaymanRayman Posts: 12,207

    @RossH Just download and installed on a relatively old computer running Win10 that didn't have Catalina before.

    The install went as expected. Having trouble with Geany though...

    The file->Open command takes a very long time to bring up the file browser, but eventually does.
    When I try to open the star trek game example, startrek.c, it crashes.
    Rebooted, but it still does this.

  • RaymanRayman Posts: 12,207
    edited 2021-10-12 22:01

    Tried on a better Win10 computer after uninstalling Catalina 3.15.4.
    Same thing.

    Well, the file-Open was lightning fast. But, it crashed after opening startrek.c.

    It shows the code for about 3 seconds then crashes with no user input.

  • RossHRossH Posts: 4,730
    edited 2021-10-12 22:31

    Thanks, Rayman. My problem is that on every computer I have installed it, it ends up working after a while ... but I'm not sure how or why.

    One thing to try - it doesn't seem to like being opened from the Start Menu straight after the install. Can you try opening a Catalina Command Line window and start geany from that using the command "catalina_geany"? It seems that once it has run successfully once, it runs ok thereafter no matter how it is started. Also, if you get it to run once, go into the Edit->Preferences menu, and on the Miscellaneous tab, select both the Project Options - i.e.:

    • "Use project-based session files"
    • "Store project files inside the projects base directory"

    I'll investigate further now that I know it is not just my imagination! :)

    Ross.

  • RaymanRayman Posts: 12,207

    @RossH Tried that, but it still crashes a couple seconds after loading...

Sign In or Register to comment.