Meaning of “Runtime Environment” and of “Software framework”?

I have heard of several things, quoted from Wikipedia:

A JVM is distributed along with a set of standard class libraries that implement the Java application programming interface (API). Appropriate APIs bundled together form the Java Runtime Environment (JRE).

Adobe Integrated Runtime, also known as Adobe AIR, is a cross-platform runtime environment developed by Adobe Systems for building Rich Internet Applications (RIA) using Adobe Flash, Adobe Flex, HTML, and Ajax, that can be run as desktop applications.

The .NET Framework (pronounced dot net) is a software framework for Microsoft Windows operating systems. It includes a large library, and it supports several programming languages which allows language interoperability (each language can use code written in other languages). The .NET library is available to all the programming languages that .NET supports.

As described above, if I understand correctly, the first two seem to be related to «runtime environment», but there is no related Wikipedia to explain what «runtime environment» is.

The third is said to be a «Software framework», which has a Wikipedia article as:

a software framework is an abstraction in which common code providing generic functionality can be selectively overridden or specialized by user code, thus providing specific functionality. Frameworks are a special case of software libraries in that they are reusable abstractions of code wrapped in a well-defined Application programming interface (API), yet they contain some key distinguishing features that separate them from normal libraries.

So my questions are:

1. Are «Runtime Environment» and «Software framework» the same thing? If not, how do they differ, and do they belong to some common category?
2. Are they all programming libraries/APIs that can be used by programmers to develop their own software?
3. The three examples are often required when installing some software. Do they belong to the concept of virtual machine? If not, what category do they belong to? How is that category different from virtual machine?

Thanks and regards!

PS: I don’t know if this post is more suitable for superuser or for stackoverflow, as the three examples are often required when installing some software, and they are also seem to be providing API for software developers.

Runtime environments: explanation and examples

We use a variety of computer programs every day, for tasks like photo editing, word processing, and calculation. It’s become expected that these programs run as fast and smoothly as possible under a variety of conditions. However, this poses a challenge for developers, since operating systems can differ significantly from each other, and different versions of the same operating system are in use at any given time. In theory, it would be necessary to adapt programs to each operating system. To avoid this extra hassle, developers use runtime environments.

Register a domain name

Build your brand on a great domain, including SSL and a personal consultant!

What is a runtime environment?

Runtime environments (RTE for short) act as small operating systems and provide all the functionality necessary for a program to run. This includes interfaces to physical parts of the hardware, user interactions, and software components.

A runtime environment loads applications and has them run on a platform. All the resources necessary for running independently of the operating system are available on this platform. That’s why, for example, playing Flash videos is only possible with the right runtime environment — in this case the Adobe Flash Player. Within this environment, Flash videos can be played in the same quality and with the same functionalities regardless of which browser or operation system is being used.

How does a runtime environment work?

An application that’s currently running interacts with the runtime environment via a runtime system. The runtime environment in turn acts as a go-between between the application and the operating system. As soon as a program is executed, it sends instructions to the computer’s processor and RAM, and accesses system resources. The runtime environment thus includes hardware, memory, variables in the environment, and interactions with the user and software components.

The term “runtime” has two meanings: In the context of runtime environments, it refers to the execution of a program in a specific runtime context. But it also has a second meaning in other contexts, namely the amount of time that a program needs to execute a task.

A runtime environment provides various basic functions for memory, networks, and hardware. These functions are carried out by the runtime environment instead of the application and work independently of the operating system. They include reading and writing files, managing input and output devices, searching and sorting files, and transporting data via networks.

The individual modules of a runtime environment are saved in runtime libraries. In Windows, you can identify these libraries based on the extension .dll (dynamic link library); in Linux they have the file suffix .so (shared object).

One major benefit of runtime environments is that programs have access to all the functionalities they need and thus work independent of operating systems. Additionally, programs have identical user interfaces regardless of whether they’re run on Windows, macOS or Linux. Developers also use runtime environments to test applications in their execution. In the case of an error, the RTE reports the reason for the crash. Frameworks are also related to runtime environments. These program structures simplify software development and can contain runtime environments that the programs are executed in.

If an application is based on a runtime environment, then the RTE is required to execute the program.

What are the advantages of runtime environments?

As mentioned above, runtime environments enable cross-platform functionality for applications. This simplifies the development process, since the program does not need to be adapted to different operating systems. If a program uses the functionalities of a runtime environment for its execution, people using different operating systems can benefit from the same functions and a near-identical user interface.

A further advantage is the conservation of resources: Similar applications can use the same runtime environments and share common components.

Well-known examples of runtime environments

One of the best examples of a runtime environment is Java: The Java Runtime Environment is a prerequisite for running Java programs. This makes Java programs largely independent of operating systems and thus able to be executed in any operating system with the right runtime environment. Since the Java Runtime Environment is a software platform, it’s called the “Java platform” and consists of a programming interface, a virtual machine, and various libraries.

Some other well-known examples of runtime environments include:

• ActionScript Application (ASAP): Offers building blocks for Flash developers.
• Blueprint: This CSS framework addresses deficits in the compatibility of browsers and simplifies the optimization of CSS. It’s also available as a CMS basis theme for Drupal and WordPress.
• CommonLanguageRuntime: A virtual runtime environment for .NET applications that interprets the Common Intermediate Language Code.
• Crystal Space: Includes a 3D engine and is used for game development and the development of other 3D visualizations; free.
• Cygwin: A runtime environment for Linux applications that allows them to run on Windows, macOS, and other operating systems.
• .NET Framework: Windows .NET applications can only be run with this Microsoft framework.
• Node.js: This JavaScript runtime environment enables the use of script languages on the server side. However, even its creator is critical of several aspects of it and is developing Deno, a new, more modern and secure runtime environment for JavaScript on the server end.
• Visual Basic Runtime: Required for several shareware and freeware programs.
• WINE: This runtime environment can be used to run Windows apps on other operating systems, such as Linux, FreeBSD, and macOS. However, it’s not 100% compatible.
• XULRunner: A runtime environment for XUL applications like Firefox, Thunderbird and Songbird. Generally these applications also run without XULRunner. However, in the future, this shared runtime environment will be implemented more consistently in order to save resources.

Web hosting with a personal consultant

Fast and scalable, including a free domain for the first year and email address, trust web hosting from IONOS!

What is GTK+Runtime Environment? Does your computer need it?

GTK+ is a runtime environment that applies to a number of operating systems. If you create an interface for a program, GTK runtime should be installed on the users’ computers so that the program runs. Most computer manufacturers do not pre-install the cross-platform runtime environment, so the users have to personally install the GTK+ Runtime Environment so that your software works as intended.

You, as a software developer, can incorporate the whole GTK runtime environment into your software. That way users need not face difficulty in using the computer program you created. You might have experienced similar issues with program distribution kits.

GTK+ Runtime Environment

A long program or software means a waste of resources. A program or software becomes long if it tries to include all the software library runtime files. Most software developers, simply create a program with just the modules needed. Then the remaining ones are managed as a different software and are converted into the runtime environment.

You might have been through the experience where when installing some software, it first asks for some C++ or VC++ Distribution Kit Install. In the same way, GTK+ Runtime Environment creates an environment where the user interfaces can work without any problem on different types of computer platforms.

GTK+ Architecture

There are four fundamental libraries that form the GTK+ runtime environment, required for your GTK applications. They are:

1. GLib
2. Cairo
3. Pango and
4. ATK

GLib is an essential library that handles data structures, based on C Language.

Cairo is used to providing support for 2D graphics that need to stay consistent on different operating systems. It also makes use of hardware acceleration wherever possible.

Pango is a code library for designing layouts. The focus here is on cross-platform usability.

ATK is a library file that contains a set of interfaces for accessibility reasons. The ATK tool helps software developers in viewing source code on a range of devices and toolkits.

GTK+ Runtime Environment is free to use, modify, and reuse commercially and you can download it from gtk.org.

Date: February 21, 2019 Tags: Developers

Related Posts

Disable Developer Tools in Microsoft Edge using Registry or Group Policy in Windows 10

Best free Xampp Server alternatives for developers

What is the JSON data format and JSON document database

[email protected]

Arun Kumar is a Microsoft MVP alumnus, obsessed with technology, especially the Internet. He deals with the multimedia content needs of training and corporate houses. Follow him on Twitter @PowercutIN

What is “runtime”?

I have heard about things like «C Runtime», «Visual C++ 2008 Runtime», «.NET Common Language Runtime», etc.

• What is «runtime» exactly?
• What is it made of?
• How does it interact with my code? Or maybe more precisely, how is my code controlled by it?

When coding assembly language on Linux, I could use the INT instruction to make the system call. So, is the runtime nothing but a bunch of pre-fabricated functions that wrap the low level function into more abstract and high level functions? But doesn’t this seem more like the definition for the library, not for the runtime?

Are «runtime» and «runtime library» two different things?

ADD 1

These days, I am thinking maybe Runtime has something in common with the so called Virtual Machine, such as JVM. Here’s the quotation that leads to such thought:

This compilation process is sufficiently complex to be broken into several layers of abstraction, and these usually involve three translators: a compiler, a virtual machine implementation, and an assembler. — The Elements of Computing Systems (Introduction, The Road Down To Hardware Land)

ADD 2

The book Expert C Programming: Deep C Secrets. Chapter 6 Runtime Data Structures is an useful reference to this question.

ADD 3 — 7:31 AM 2/28/2021

Here’s some of my perspective after getting some knowledge about processor design. The whole computer thing is just multiple levels of abstraction. It goes from elementary transistors all the way up to the running program. For any level N of abstraction, its runtime is the immediate level N-1 of abstraction that goes below it. And it is God that give us the level 0 of abstraction.

15 Answers 15

Runtime describes software/instructions that are executed while your program is running, especially those instructions that you did not write explicitly, but are necessary for the proper execution of your code.

Low-level languages like C have very small (if any) runtime. More complex languages like Objective-C, which allows for dynamic message passing, have a much more extensive runtime.

You are correct that runtime code is library code, but library code is a more general term, describing the code produced by any library. Runtime code is specifically the code required to implement the features of the language itself.

Runtime is a general term that refers to any library, framework, or platform that your code runs on.

The C and C++ runtimes are collections of functions.

The .NET runtime contains an intermediate language interpreter, a garbage collector, and more.

In computer programming, a runtime library is a special program library used by a compiler, to implement functions built into a programming language, during the runtime (execution) of a computer program. This often includes functions for input and output, or for memory management.

A run-time system (also called runtime system or just runtime) is software designed to support the execution of computer programs written in some computer language. The run-time system contains implementations of basic low-level commands and may also implement higher-level commands and may support type checking, debugging, and even code generation and optimization. Some services of the run-time system are accessible to the programmer through an application programming interface, but other services (such as task scheduling and resource management) may be inaccessible.

Re: your edit, «runtime» and «runtime library» are two different names for the same thing.

The runtime or execution environment is the part of a language implementation which executes code and is present at run-time; the compile-time part of the implementation is called the translation environment in the C standard.

Examples:

the Java runtime consists of the virtual machine and the standard library

a common C runtime consists of the loader (which is part of the operating system) and the runtime library, which implements the parts of the C language which are not built into the executable by the compiler; in hosted environments, this includes most parts of the standard library

In my understanding runtime is exactly what it means — the time when the program is run. You can say something happens at runtime / run time or at compile time.

I think runtime and runtime library should be (if they aren’t) two separate things. «C runtime» doesn’t seem right to me. I call it «C runtime library».

Answers to your other questions: I think the term runtime can be extended to include also the environment and the context of the program when it is run, so:

• it consists of everything that can be called «environment» during the time when the program is run, for example other processes, state of the operating system and used libraries, state of other processes, etc
• it doesn’t interact with your code in a general sense, it just defines in what circumstances your code works, what is available to it during execution.

This answer is to some extend just my opinion, not a fact or definition.

Matt Ball answered it correctly. I would say about it with examples.

Consider running a program compiled in Turbo-Borland C/C++ (version 3.1 from the year 1991) compiler and let it run under a 32-bit version of windows like Win 98/2000 etc.

It’s a 16-bit compiler. And you will see all your programs have 16-bit pointers. Why is it so when your OS is 32bit? Because your compiler has set up the execution environment of 16 bit and the 32-bit version of OS supported it.

What is commonly called as JRE (Java Runtime Environment) provides a Java program with all the resources it may need to execute.

Actually, runtime environment is brain product of idea of Virtual Machines. A virtual machine implements the raw interface between hardware and what a program may need to execute. The runtime environment adopts these interfaces and presents them for the use of the programmer. A compiler developer would need these facilities to provide an execution environment for its programs.

Run time exactly where your code comes into life and you can see lot of important thing your code do.

Runtime has a responsibility of allocating memory , freeing memory , using operating system’s sub system like (File Services, IO Services.. Network Services etc.)

Your code will be called «WORKING IN THEORY» until you practically run your code. and Runtime is a friend which helps in achiving this.

Runtime basically means when program interacts with the hardware and operating system of a machine. C does not have it’s own runtime but instead, it requests runtime from an operating system (which is basically a part of ram) to execute itself.

a runtime could denote the current phase of program life (runtime / compile time / load time / link time) or it could mean a runtime library, which form the basic low level actions that interface with the execution environment. or it could mean a runtime system, which is the same as an execution environment.

in the case of C programs, the runtime is the code that sets up the stack, the heap etc. which a requirement expected by the C environment. it essentially sets up the environment that is promised by the language. (it could have a runtime library component, crt0.lib or something like that in case of C)

I found that the following folder structure makes a very insightful context for understanding what runtime is:

You can see that there is the ‘source‘, there is the ‘SDK‘ or ‘Software Development Kit’ and then there is the Runtime , eg. the stuff that gets run — at runtime. It’s contents are like:

The win32 zip contains .exe -s and .dll -s.

So eg. the C runtime would be the files like this — C runtime libraries, .so-s or .dll -s — you run at runtime, made special by their (or their contents’ or purposes’) inclusion in the definition of the C language (on ‘paper’), then implemented by your C implementation of choice. And then you get the runtime of that implementation, to use it and to build upon it.

That is, with a little polarisation, the runnable files that the users of your new C-based program will need. As a developer of a C-based program, so do you, but you need the C compiler and the C library headers, too; the users don’t need those.

I’m not crazy about the other answers here; they’re too vague and abstract for me. I think more in stories. Here’s my attempt at a better answer.

a BASIC example

Let’s say it’s 1985 and you write a short BASIC program on an Apple II:

So far, your program is just source code. It’s not running, and we would say there is no «runtime» involved with it.

But now I run it:

How is it actually running? How does it know how to send the string parameter from PRINT to the physical screen? I certainly didn’t provide any system information in my code, and PRINT itself doesn’t know anything about my system.

Instead, RUN is actually a program itself — its code tells it how to parse my code, how to execute it, and how to send any relevant requests to the computer’s operating system. The RUN program provides the «runtime» environment that acts as a layer between the operating system and my source code. The operating system itself acts as part of this «runtime», but we usually don’t mean to include it when we talk about a «runtime» like the RUN program.

Types of compilation and runtime

Compiled binary languages

In some languages, your source code must be compiled before it can be run. Some languages compile your code into machine language — it can be run by your operating system directly. This compiled code is often called «binary» (even though every other kind of file is also in binary :).

In this case, there is still a minimal «runtime» involved — but that runtime is provided by the operating system itself. The compile step means that many statements that would cause your program to crash are detected before the code is ever run.

C is one such language; when you run a C program, it’s totally able to send illegal requests to the operating system (like, «give me control of all of the memory on the computer, and erase it all»). If an illegal request is hit, usually the OS will just kill your program and not tell you why, and dump the contents of that program’s memory at the time it was killed to a .dump file that’s pretty hard to make sense of. But sometimes your code has a command that is a very bad idea, but the OS doesn’t consider it illegal, like «erase a random bit of memory this program is using»; that can cause super weird problems that are hard to get to the bottom of.

Bytecode languages

Other languages compile your code into a language that the operating system can’t read directly, but a specific runtime program can read your compiled code. This compiled code is often called «bytecode».

The more elaborate this runtime program is, the more extra stuff it can do on the side that your code did not include (even in the libraries you use) — for instance, the Java runtime environment («JRE») can keep track of memory assignments that are no longer needed, and tell the operating system it’s safe to reuse that memory for something else, and it can catch situations where your code would try to send an illegal request to the operating system, and instead exit with a readable error.

All of this overhead makes them slower than compiled binary languages, but it makes the runtime powerful and flexible; in some cases, it can even pull in other code after it starts running, without having to start over. The compile step means that many statements that would cause your program to crash are detected before the code is ever run; and the powerful runtime can keep your code from doing stupid things (e.g., you can’t «erase a random bit of memory this program is using»).

Scripting languages

Still other languages don’t precompile your code at all; the runtime does all of the work of reading your code line by line, interpreting it and executing it. This makes them even slower than «bytecode» languages, but also even more flexible; in some cases, you can even fiddle with your source code as it runs! Though it also means that you can have a totally illegal statement in your code, and it could sit there in your production code without drawing attention, until one day it is run and causes a crash.