Split (1)

train · ~858k rows (showing the first 350k)

url stringlengths 11 2.25k	text stringlengths 88 50k	ts timestamp[s]date 2026-01-13 08:47:33 2026-01-13 09:30:40
https://www.npopov.com/2017/04/14/PHP-7-Virtual-machine.html	PHP 7 Virtual Machine Blog by nikic . Find me on GitHub , StackOverflow , Twitter and Mastodon . Learn more about me . « Back to article overview. PHP 7 Virtual Machine 14. April 2017 This article aims to provide an overview of the Zend Virtual Machine, as it is found in PHP 7. This is not a comprehensive description, but I try to cover most of the important parts, as well as some of the finer details. This description targets PHP version 7.2 (currently in development), but nearly everything also applies to PHP 7.0/7.1. However, the differences to the PHP 5.x series VM are significant and I will generally not bother to draw parallels. Most of this post will consider things at the level of instruction listings and only a few sections at the end deal with the actual C level implementation of the VM. However, I do want to provide some links to the main files that make up the VM upfront: zend_vm_def.h : The VM definition file. zend_vm_execute.h : The generated virtual machine. zend_vm_gen.php : The generating script. zend_execute.c : Most of the direct support code. Opcodes In the beginning, there was the opcode. “Opcode” is how we refer to a full VM instruction (including operands), but may also designate only the “actual” operation code, which is a small integer determining the type of instruction. The intended meaning should be clear from context. In source code, full instructions are usually called “oplines”. An individual instruction conforms to the following zend_op structure: struct _zend_op { const void * handler ; znode_op op1 ; znode_op op2 ; znode_op result ; uint32_t extended_value ; uint32_t lineno ; zend_uchar opcode ; zend_uchar op1_type ; zend_uchar op2_type ; zend_uchar result_type ; }; As such, opcodes are essentially a “three-address code” instruction format. There is an opcode determining the instruction type, there are two input operands op1 and op2 and one output operand result . Not all instructions use all operands. An ADD instruction (representing the + operator) will use all three. A BOOL_NOT instruction (representing the ! operator) uses only op1 and result. An ECHO instruction uses only op1. Some instructions may either use or not use an operand. For example DO_FCALL may or may not have a result operand, depending on whether the return value of the function call is used. Some instructions require more than two input operands, in which case they will simply use a second dummy instruction ( OP_DATA ) to carry additional operands. Next to these three standard operands, there exists an additional numeric extended_value field, which can be used to hold additional instruction modifiers. For example for a CAST it might contain the target type to cast to. Each operand has a type, stored in op1_type , op2_type and result_type respectively. The possible types are IS_UNUSED , IS_CONST , IS_TMPVAR , IS_VAR and IS_CV . The three latter types designated a variable operand (with three different types of VM variables), IS_CONST denotes a constant operand ( 5 or "string" or even [1, 2, 3] ), while IS_UNUSED denotes an operand that is either actually unused, or which is used as a 32-bit numeric value (an “immediate”, in assembly jargon). Jump instructions for example will store the jump target in an UNUSED operand. Obtaining opcode dumps In the following, I’ll often show opcode sequences that PHP generates for some example code. There are currently three ways by which such opcode dumps may be obtained: # Opcache, since PHP 7.1 php -d opcache.opt_debug_level = 0x10000 test.php # phpdbg, since PHP 5.6 phpdbg -p * test.php # vld, third-party extension php -d vld.active = 1 test.php Of these, opcache provides the highest-quality output. The listings used in this article are based on opcache dumps, with minor syntax adjustments. The magic number 0x10000 is short for “before optimization”, so that we see the opcodes as the PHP compiler produced them. 0x20000 would give you optimized opcodes. Opcache can also generate a lot more information, for example 0x40000 will produce a CFG, while 0x200000 will produce type- and range-inferred SSA form. But that’s getting ahead of ourselves: plain old linearized opcode dumps are sufficient for our purposes. Variable types Likely one of the most important points to understand when dealing with the PHP virtual machine, are the three distinct variable types it uses. In PHP 5 TMPVAR, VAR and CV had very different representations on the VM stack, along with different ways of accessing them. In PHP 7 they have become very similar in that they share the same storage mechanism. However there are important differences in the values they can contain and their semantics. CV is short for “compiled variable” and refers to a “real” PHP variable. If a function uses variable $a , there will be a corresponding CV for $a . CVs can have UNDEF type, to denote undefined variables. If an UNDEF CV is used in an instruction, it will (in most cases) throw the well-known “undefined variable” notice. On function entry all non-argument CVs are initialized to be UNDEF. CVs are not consumed by instructions, e.g. an instruction ADD $a, $b will not destroy the values stored in CVs $a and $b . Instead all CVs are destroyed together on scope exit. This also implies that all CVs are “live” for the entire duration of function, where “live” here refers to containing a valid value (not live in the data flow sense). TMPVARs and VARs on the other hand are virtual machine temporaries. They are typically introduced as the result operand of some operation. For example the code $a = $b + $c + $d will result in an opcode sequence similar to the following: T0 = ADD $b, $c T1 = ADD T0, $d ASSIGN $a, T1 TMP/VARs are always defined before use and as such cannot hold an UNDEF value. Unlike CVs, these variable types are consumed by the instructions they’re used in. In the above example, the second ADD will destroy the value of the T0 operand and T0 must not be used after this point (unless it is written to beforehand). Similarly, the ASSIGN will consume the value of T1, invalidating T1. It follows that TMP/VARs are usually very short-lived. In a large number of cases a temporary only lives for the space of a single instruction. Outside this short liveness interval, the value in the temporary is garbage. So what’s the difference between TMP and VAR? Not much. The distinction was inherited from PHP 5, where TMPs were VM stack allocated, while VARs were heap allocated. In PHP 7 all variables are stack allocated. As such, nowadays the main difference between TMPs and VARs is that only the latter are allowed to contain REFERENCEs (this allows us to elide DEREFs on TMPs). Furthermore VARs may hold two types of special values, namely class entries and INDIRECT values. The latter are used to handle non-trivial assignments. The following table attempts to summarize the main differences: \| UNDEF \| REF \| INDIRECT \| Consumed? \| Named? \| -------\|-------\|-----\|----------\|-----------\|--------\| CV \| yes \| yes \| no \| no \| yes \| TMPVAR \| no \| no \| no \| yes \| no \| VAR \| no \| yes \| yes \| yes \| no \| Op arrays All PHP functions are represented as structures that have a common zend_function header. “Function” here is to be understood somewhat broadly and includes everything from “real” functions, over methods, down to free-standing “pseudo-main” code and “eval” code. Userland functions use the zend_op_array structure. It has more than 30 members, so I’m starting with a reduced version for now: struct _zend_op_array { /* Common zend_function header here / / ... / uint32_t last ; zend_op opcodes ; int last_var ; uint32_t T ; zend_string ** vars ; /* ... / int last_literal ; zval literals ; /* ... / }; The most important part here are of course the opcodes , which is an array of opcodes (instructions). last is the number of opcodes in this array. Note that the terminology is confusing here, as last sounds like it should be the index of the last opcode, while it really is the number of opcodes (which is one greater than the last index). The same applies to all other last_ values in the op array structure. last_var is the number of CVs, and T is the number of TMPs and VARs (in most places we make no strong distinction between them). vars in array of names for CVs. literals is an array of literal values occurring in the code. This array is what CONST operands reference. Depending on the ABI, each CONST operand will either a store a pointer into this literals table, or store an offset relative to its start. There is more to the op array structure than this, but it can wait for later. Stack frame layout Apart from some executor globals (EG), all execution state is stored on the virtual machine stack. The VM stack is allocated in pages of 256 KiB and individual pages are connected through a linked list. On each function call, a new stack frame is allocated on the VM stack, with the following layout: +----------------------------------------+ \| zend_execute_data \| +----------------------------------------+ \| VAR[0] = ARG[1] \| arguments \| ... \| \| VAR[num_args-1] = ARG[N] \| \| VAR[num_args] = CV[num_args] \| remaining CVs \| ... \| \| VAR[last_var-1] = CV[last_var-1] \| \| VAR[last_var] = TMP[0] \| TMP/VARs \| ... \| \| VAR[last_var+T-1] = TMP[T] \| \| ARG[N+1] (extra_args) \| extra arguments \| ... \| +----------------------------------------+ The frame starts with a zend_execute_data structure, followed by an array of variable slots. The slots are all the same (simple zvals), but are used for different purposes. The first last_var slots are CVs, of which the first num_args holds function arguments. The CV slots are followed by T slots for TMP/VARs. Lastly, there can sometimes be “extra” arguments stored at the end of the frame. These are used for handling func_get_args() . CV and TMP/VAR operands in instructions are encoded as offsets relative to the start of the stack frame, so fetching a certain variable is simply an offseted read from the execute_data location. The execute data at the start of the frame is defined as follows: struct _zend_execute_data { const zend_op * opline ; zend_execute_data * call ; zval * return_value ; zend_function * func ; zval This ; /* this + call_info + num_args / zend_class_entry called_scope ; zend_execute_data * prev_execute_data ; zend_array * symbol_table ; void ** run_time_cache ; /* cache op_array->run_time_cache / zval literals ; /* cache op_array->literals / }; Most importantly, this structure contains opline , which is the currently executed instruction, and func , which is the currently executed function. Furthermore: return_value is a pointer to the zval into the which the return value will be stored. This is the $this object, but also encodes the number of function arguments and a couple of call metadata flags in some unused zval space. called_scope is the scope that static:: refers to in PHP code. prev_execute_data points to the previous stack frame, to which execution will return after this function finished running. symbol_table is a typically unused symbol table used in case some crazy person actually uses variable variables or similar features. run_time_cache caches the op array runtime cache, in order to avoid one pointer indirection when accessing this structure (which is discussed later). literals caches the op array literals table for the same reason. Function calls I’ve skipped one field in the execute_data structure, namely call , as it requires some further context about how function calls work. All calls use a variation on the same instruction sequence. A var_dump($a, $b) in global scope will compile to: INIT_FCALL (2 args) "var_dump" SEND_VAR $a SEND_VAR $b V0 = DO_ICALL # or just DO_ICALL if retval unused There are eight different types of INIT instructions depending on what kind of call it is. INIT_FCALL is used for calls to free functions that we recognize at compile time. Similarly there are ten different SEND opcodes depending on the type of the arguments and the function. There is only a modest number of four DO_CALL opcodes, where ICALL is used for calls to internal functions. While the specific instructions may differ, the structure is always the same: INIT, SEND, DO. The main issue that the call sequence has to contend with are nested function calls, which compile something like this: # var_dump(foo($a), bar($b)) INIT_FCALL (2 args) "var_dump" INIT_FCALL (1 arg) "foo" SEND_VAR $a V0 = DO_UCALL SEND_VAR V0 INIT_FCALL (1 arg) "bar" SEND_VAR $b V1 = DO_UCALL SEND_VAR V1 V2 = DO_ICALL I’ve indented the opcode sequence to visualize which instructions correspond to which call. The INIT opcode pushes a call frame on the stack, which contains enough space for all the variables in the function and the number of arguments we know about (if argument unpacking is involved, we may end up with more arguments). This call frame is initialized with the called function, $this and the called_scope (in this case the latter are both NULL, as we’re calling free functions). A pointer to the new frame is stored into execute_data->call , where execute_data is the frame of the calling function. In the following we’ll denote such accesses as EX(call) . Notably, the prev_execute_data of the new frame is set to the old EX(call) value. For example, the INIT_FCALL for call foo will set the prev_execute_data to the stack frame of the var_dump (rather than that of the surrounding function). As such, prev_execute_data in this case forms a linked list of “unfinished” calls, while usually it would provide the backtrace chain. The SEND opcodes then proceed to push arguments into the variable slots of EX(call) . At this point the arguments are all consecutive and may overflow from the section designated for arguments into other CVs or TMPs. This will be fixed later. Lastly DO_FCALL performs the actual call. What was EX(call) becomes the current function and prev_execute_data is relinked to the calling function. Apart from that, the call procedure depends on what kind of function it is. Internal functions only need to invoke a handler function, while userland functions need to finish initialization of the stack frame. This initialization involves fixing up the argument stack. PHP allows passing more arguments to a function than it expects (and func_get_args relies on this). However, only the actually declared arguments have corresponding CVs. Any arguments beyond this will write into memory reserved for other CVs and TMPs. As such, these arguments will be moved after the TMPs, ending up with arguments segmented into two non-continuous chunks. To have it clearly stated, userland function calls do not involve recursion at the virtual machine level. They only involve a switch from one execute_data to another, but the VM continues running in a linear loop. Recursive virtual machine invocations only occur if internal functions invoke userland callbacks (e.g. through array_map ). This is the reason why infinite recursion in PHP usually results in a memory limit or OOM error, but it is possible to trigger a stack overflow by recursion through callback-functions or magic methods. Argument sending PHP uses a large number of different argument sending opcodes, whose differences can be confusing, no thanks to some unfortunate naming. SEND_VAL and SEND_VAR are the simplest variants, which handle sending of by-value arguments that are known to be by-value at compile time. SEND_VAL is used for CONST and TMP operands, while SEND_VAR is for VARs and CVs. SEND_REF conversely, is used for arguments that are known to be by-reference during compilation. As only variables can be sent by reference, this opcode only accepts VARs and CVs. SEND_VAL_EX and SEND_VAR_EX are variants of SEND_VAL/SEND_VAR for cases where we cannot determine statically whether the argument is by-value or by-reference. These opcodes will check the kind of the argument based on arginfo and behave accordingly. In most cases the actual arginfo structure is not used, but rather a compact bit vector representation directly in the function structure. And then there is SEND_VAR_NO_REF_EX. Don’t try to read anything into its name, it’s outright lying. This opcode is used when passing something that isn’t really a “variable” but does return a VAR to a statically unknown argument. Two particular examples where it is used are passing the result of a function call as an argument, or passing the result of an assignment. This case needs a separate opcode for two reasons: Firstly, it will generate the familiar “Only variables should be passed by reference” notice if you try to pass something like an assignment by ref (if SEND_VAR_EX were used instead, it would have been silently allowed). Secondly, this opcode deals with the case that you might want to pass the result of a reference-returning function to a by-reference argument (which should not throw anything). The SEND_VAR_NO_REF variant of this opcode (without the _EX) is a specialized variant for the case where we statically know that a reference is expected (but we don’t know whether the argument is one). The SEND_UNPACK and SEND_ARRAY opcodes deal with argument unpacking and inlined call_user_func_array calls respectively. They both push the elements from an array onto the argument stack and differ in various details (e.g. unpacking supports Traversables while call_user_func_array does not). If unpacking/cufa is used, it may be necessary to extend the stack frame beyond its previous size (as the real number of function arguments is not known at the time of initialization). In most cases this extension can happen simply by moving the stack top pointer. However if this would cross a stack page boundary, a new page has to be allocated and the entire call frame (including already pushed arguments) needs to be copied to the new page (we are not be able to handle a call frame crossing a page boundary). The last opcode is SEND_USER, which is used for inlined call_user_func calls and deals with some of its peculiarities. While we haven’t yet discussed the different variable fetch modes, this seems like a good place to introduce the FUNC_ARG fetch mode. Consider a simple call like func($a[0][1][2]) , for which we do not know at compile-time whether the argument will be passed by-value or by-reference. In both cases the behavior will be wildly different. If the pass is by-value and $a was previously empty, this could would have to generate a bunch of “undefined index” notices. If the pass is by-reference we’d have to silently initialize the nested arrays instead. The FUNC_ARG fetch mode will dynamically choose one of the two behaviors (R or W), by inspecting the arginfo of the current EX(call) function. For the func($a[0][1][2]) example, the opcode sequence might look something like this: INIT_FCALL_BY_NAME "func" V0 = FETCH_DIM_FUNC_ARG (arg 1) $a, 0 V1 = FETCH_DIM_FUNC_ARG (arg 1) V0, 1 V2 = FETCH_DIM_FUNC_ARG (arg 1) V1, 2 SEND_VAR_EX V2 DO_FCALL Fetch modes The PHP virtual machine has four classes of fetch opcodes: FETCH_ // $_GET, $$var FETCH_DIM_* // $arr[0] FETCH_OBJ_* // $obj->prop FETCH_STATIC_PROP_* // A::$prop These do precisely what one would expect them to do, with the caveat that the basic FETCH_* variant is only used to access variable-variables and superglobals: normal variable accesses go through the much faster CV mechanism instead. These fetch opcodes each come in six variants: _R _RW _W _IS _UNSET _FUNC_ARG We’ve already learned that _FUNC_ARG chooses between _R and _W depending on whether a function argument is by-value or by-reference. Let’s try to create some situations where we would expect the different fetch types to appear: // $arr[0]; V2 = FETCH_DIM_R $arr int(0) FREE V2 // $arr[0] = $val; ASSIGN_DIM $arr int(0) OP_DATA $val // $arr[0] += 1; ASSIGN_ADD (dim) $arr int(0) OP_DATA int(1) // isset($arr[0]); T5 = ISSET_ISEMPTY_DIM_OBJ (isset) $arr int(0) FREE T5 // unset($arr[0]); UNSET_DIM $arr int(0) Unfortunately, the only actual fetch this produced is FETCH_DIM_R: Everything else is handled through special opcodes. Note that ASSIGN_DIM and ASSIGN_ADD both use an extra OP_DATA, because they need more than two input operands. The reason why special opcodes like ASSIGN_DIM are used, instead of something like FETCH_DIM_W + ASSIGN, is (apart from performance) that these operations may be overloaded, e.g., in the ASSIGN_DIM case by means of an object implementing ArrayAccess::offsetSet(). To actually generate the different fetch types we need to increase the level of nesting: // $arr[0][1]; V2 = FETCH_DIM_R $arr int(0) V3 = FETCH_DIM_R V2 int(1) FREE V3 // $arr[0][1] = $val; V4 = FETCH_DIM_W $arr int(0) ASSIGN_DIM V4 int(1) OP_DATA $val // $arr[0][1] += 1; V6 = FETCH_DIM_RW $arr int(0) ASSIGN_ADD (dim) V6 int(1) OP_DATA int(1) // isset($arr[0][1]); V8 = FETCH_DIM_IS $arr int(0) T9 = ISSET_ISEMPTY_DIM_OBJ (isset) V8 int(1) FREE T9 // unset($arr[0][1]); V10 = FETCH_DIM_UNSET $arr int(0) UNSET_DIM V10 int(1) Here we see that while the outermost access uses specialized opcodes, the nested indexes will be handled using FETCHes with an appropriate fetch mode. The fetch modes essentially differ by a) whether they generate an “undefined offset” notice if the index doesn’t exist, and whether they fetch the value for writing: \| Notice? \| Write? R \| yes \| no W \| no \| yes RW \| yes \| yes IS \| no \| no UNSET \| no \| yes-ish The case of UNSET is a bit peculiar, in that it will only fetch existing offsets for writing, and leave undefined ones alone. A normal write-fetch would initialize undefined offsets instead. Writes and memory safety Write fetches return VARs that may contain either a normal zval or an INDIRECT pointer to another zval. Of course, in the former case any changes applied to the zval will not be visible, as the value is only accessible through a VM temporary. While PHP prohibits expression such as [][0] = 42 , we still need to handle this for cases like call()[0] = 42 . Depending on whether call() returns by-value or by-reference, this expression may or may not have an observable effect. The more typical case is when the fetch returns an INDIRECT, which contains a pointer to the storage location that is being modified, for example a certain location in a hashtable data array. Unfortunately, such pointers are fragile things and easily invalidated: any concurrent write to the array might trigger a reallocation, leaving behind a dangling pointer. As such, it is critical to prevent the execution of user code between the point where an INDIRECT value is created and where it is consumed. Consider this example: $arr [ a ()][ b ()] = c (); Which generates: INIT_FCALL_BY_NAME (0 args) "a" V1 = DO_FCALL_BY_NAME INIT_FCALL_BY_NAME (0 args) "b" V3 = DO_FCALL_BY_NAME INIT_FCALL_BY_NAME (0 args) "c" V5 = DO_FCALL_BY_NAME V2 = FETCH_DIM_W $arr V1 ASSIGN_DIM V2 V3 OP_DATA V5 Notably, this sequence first executes all side-effects from left to right and only then performs any necessary write fetches (we refer to the FETCH_DIM_W here as a “delayed opline”). This ensures that the write-fetch and the consuming instruction are directly adjacent. Consider another example: $arr [ 0 ] =& $arr [ 1 ]; Here we have a bit of problem: Both sides of the assignment must be fetched for write. However, if we fetch $arr[0] for write and then $arr[1] for write, the latter might invalidate the former. This problem is solved as follows: V2 = FETCH_DIM_W $arr 1 V3 = MAKE_REF V2 V1 = FETCH_DIM_W $arr 0 ASSIGN_REF V1 V3 Here $arr[1] is fetched for write first, then turned into a reference using MAKE_REF. The result of MAKE_REF is no longer INDIRECT and not subject to invalidation, as such the fetch of $arr[0] can be performed safely. Exception handling Exceptions are the root of all evil. An exception is generated by writing an exception into EG(exception) , where EG refers to executor globals. Throwing exceptions from C code does not involve stack unwinding, instead the abortion will propagate upwards through return value failure codes or checks for EG(exception) . The exception is only actually handled when control reenters the virtual machine code. Nearly all VM instructions can directly or indirectly result in an exception under some circumstances. For example any “undefined variable” notice can result in an exception if a custom error handler is used. We want to avoid checking whether EG(exception) has been set after each VM instruction. Instead a small trick is used: When an exception is thrown the current opline of the current execute data is replaced with a dummy HANDLE_EXCEPTION opline (this obviously does not modify the op array, it only redirects a pointer). The opline at which the exception originated is backed up into EG(opline_before_exception) . This means that when control returns into the main virtual machine dispatch loop, the HANDLE_EXCEPTION opcode will be invoked. There is a slight problem with this scheme: It requires that a) the opline stored in the execute data is actually the currently executed opline (otherwise opline_before_exception would be wrong) and b) the virtual machine uses the opline from the execute data to continue execution (otherwise HANDLE_EXCEPTION will not be invoked). While these requirements may sound trivial, they are not. The reason is that the virtual machine may be working on a different opline variable that is out-of-sync with the opline stored in execute data. Before PHP 7 this only happened in the rarely used GOTO and SWITCH virtual machines, while in PHP 7 this is actually the default mode of operation: If the compiler supports it, the opline is stored in a global register. As such, before performing any operation that might possibly throw, the local opline must be written back into the execute data (SAVE_OPLINE operation). Similarly, after any potentially throwing operation the local opline must be populated from execute data (mostly a CHECK_EXCEPTION operation). Now, this machinery is what causes a HANDLE_EXCEPTION opcode to execute after an exception is thrown. But what does it do? First of all, it determines whether the exception was thrown inside a try block. For this purpose the op array contains an array of try_catch_elements that track opline offsets for try, catch and finally blocks: typedef struct _zend_try_catch_element { uint32_t try_op ; uint32_t catch_op ; /* ketchup! / uint32_t finally_op ; uint32_t finally_end ; } zend_try_catch_element ; For now we will pretend that finally blocks do not exist, as they are a whole different rabbit hole. Assuming that we are indeed inside a try block, the VM needs to clean up all unfinished operations that started before the throwing opline and don’t span past the end of the try block. This involves freeing the stack frames and associated data of all calls currently in flight, as well as freeing live temporaries. In the majority of cases temporaries are short-lived to the point that the consuming instruction directly follows the generating one. However it can happen that the live-range spans multiple, potentially throwing instructions: # (array)[] + throwing() L0: T0 = CAST (array) [] L1: INIT_FCALL (0 args) "throwing" L2: V1 = DO_FCALL L3: T2 = ADD T0, V1 In this case the T0 variable is live during instructions L1 and L2, and as such would need to be destroyed if the function call throws. One particular type of temporary tends to have particularly long live ranges: Loop variables. For example: # foreach ($array as $value) throw $ex; L0: V0 = FE_RESET_R $array, ->L4 L1: FE_FETCH_R V0, $value, ->L4 L2: THROW $ex L3: JMP ->L1 L4: FE_FREE V0 Here the “loop variable” V0 lives from L1 to L3 (generally always spanning the entire loop body). Live ranges are stored in the op array using the following structure: typedef struct _zend_live_range { uint32_t var ; / low bits are used for variable type (ZEND_LIVE_* macros) / uint32_t start ; uint32_t end ; } zend_live_range ; Here var is the (operand encoded) variable the range applies to, start is the start opline offset (not including the generating instruction), while end if the end opline offset (including the consuming instruction). Of course live ranges are only stored if the temporary is not immediately consumed. The lower bits of var are used to store the type of the variable, which can be one of: ZEND_LIVE_TMPVAR: This is a “normal” variable. It holds an ordinary zval value. Freeing this variable behaves like a FREE opcode. ZEND_LIVE_LOOP: This is a foreach loop variable, which holds more than a simple zval. This corresponds to a FE_FREE opcode. ZEND_LIVE_SILENCE: This is used for implementing the error suppression operator. The old error reporting level is backed up into a temporary and later restored. If an exception is thrown we obviously want to restore it as well. This corresponds to END_SILENCE. ZEND_LIVE_ROPE: This is used for rope string concatenations, in which case the temporary is a fixed-sized array of zend_string pointers living on the stack. In this case all the strings that have already been populated must be freed. Corresponds approximately to END_ROPE. A tricky question to consider in this context is whether temporaries should be freed, if either their generating or their consuming instruction throws. Consider the following simple code: T2 = ADD T0, T1 ASSIGN $v, T2 If an exception is thrown by the ADD, should the T2 temporary be automatically freed, or is the ADD instruction responsible for this? Similarly, if the ASSIGN throws, should T2 be freed automatically, or must the ASSIGN take care of this itself? In the latter case the answer is clear: An instruction is always responsible for freeing its operands, even if an exception is thrown. The case of the result operand is more tricky, because the answer here changed between PHP 7.1 and 7.2: In PHP 7.1 the instruction was responsible for freeing the result in case of an exception. In PHP 7.2 it is automatically freed (and the instruction is responsible for making sure the result is always populated). The motivation for this change is the way that many basic instructions (such as ADD) are implemented. Their usual structure goes roughly as follows: 1. read input operands 2. perform operation, write it into result operand 3. free input operands (if necessary) This is problematic, because PHP is in the very unfortunate position of not only supporting exceptions and destructors, but also supporting throwing destructors (this is the point where compiler engineers cry out in horror). As such, step 3 can throw, at which point the result is already populated. To avoid memory leaks in this edge-case, responsiblility for freeing the result operand has been shifted from the instruction to the exception handling mechanism. Once we have performed these cleanup operations, we can continue executing the catch block. If there is no catch (and no finally) we unwind the stack, i.e. destroy the current stack frame and give the parent frame a shot at handling the exception. So you get a full appreciation for how ugly the whole exception handling business is, I’ll relate another tidbit related to throwing destructors. It’s not remotely relevant in practice, but we still need to handle it to ensure correctness. Consider this code: foreach ( new Dtor as $value ) { try { echo "Return" ; return ; } catch ( Exception $e ) { echo "Catch" ; } } Now imagine that Dtor is a Traversable class with a throwing destructor. This code will result in the following opcode sequence, with the loop body indented for readability: L0: V0 = NEW 'Dtor', ->L2 L1: DO_FCALL L2: V2 = FE_RESET_R V0, ->L11 L3: FE_FETCH_R V2, $value L4: ECHO 'Return' L5: FE_FREE (free on return) V2 # <- return L6: RETURN null # <- return L7: JMP ->L10 L8: CATCH 'Exception' $e L9: ECHO 'Catch' L10: JMP ->L3 L11: FE_FREE V2 # <- the duplicated instr Importantly, note that the “return” is compiled to a FE_FREE of the loop variable and a RETURN. Now, what happens if that FE_FREE throws, because Dtor has a throwing destructor? Normally, we would say that this instruction is within the try block, so we should be invoking the catch. However, at this point the loop variable has already been destroyed! The catch discards the exception and we’ll try to continue iterating an already dead loop variable. The cause of this problem is that, while the throwing FE_FREE is inside the try block, it is a copy of the FE_FREE in L11. Logically that is where the exception “really” occurred. This is why the FE_FREE generated by the break is annotated as being a FREE_ON_RETURN. This instructs the exception handling mechanism to move the source of the exception to the original freeing instruction. As such the above code will not run the catch block, it will generate an uncaught exception instead. Finally handling PHP’s history with finally blocks is somewhat troubled. PHP 5.5 first introduced finally blocks, or rather: a really buggy implementation of finally blocks. Each of PHP 5.6, 7.0 and 7.1 shipped with major rewrites of the finally implementation, each fixing a whole slew of bugs, but not quite managing to reach a fully correct implementation. It looks like PHP 7.1 finally managed to hit the nail (fingers crossed). While writing this section, I was surprised to find that from the perspective of the current implementation and my current understanding, finally handling is actually not all that complicated. Indeed, in many ways the implementation became simpler through the different iterations, rather than more complex. This goes to show how an insufficient understanding of a problem can result in an implementation that is both excessively complex and buggy (although, to be fair, part of the complexity of the PHP 5 implementation stemmed directly from the lack of an AST). Finally blocks are run whenever control exits a try block, either normally (e.g. using return) or abnormally (by throwing). There are a couple interesting edge-cases to consider, which I’ll quickly illustrate before going into the implementation. Consider: try { throw new Exception (); } finally { return 42 ; } What happens? Finally wins and the function returns 42. Consider: try { return 24 ; } finally { return 42 ; } Again finally wins and the function returns 42. The finally always wins. PHP prohibits jumps out of finally blocks. For example the following is forbidden: foreach ( $array as $value ) { try { return 42 ; } finally { continue ; } } The “continue” in the above code sample will generate a compile-error. It is important to understand that this limitation is purely cosmetic and can be easily worked around by using the “well-known” catch control delegation pattern: foreach ( $array as $value ) { try { try { return 42 ; } finally { throw new JumpException ; } } catch ( JumpException $e ) { continue ; } } The only real limitation that exists is that it is not possible to jump into a finally block, e.g. performing a goto from outside a finally to a label inside a finally is forbidden. With the preliminaries out of the way, we can look at how finally works. The implementation uses two opcodes, FAST_CALL and FAST_RET. Roughly, FAST_CALL is for jumping into a finally block and FAST_RET is for jumping out of it. Let’s consider the simplest case: try { echo "try" ; } finally { echo "finally" ; } echo "finished" ; This code compiles down to the following opcode sequence: L0: ECHO string("try") L1: T0 = FAST_CALL ->L3 L2: JMP ->L5 L3: ECHO string("finally") L4: FAST_RET T0 L5: ECHO string("finished") L6: RETURN int(1) The FAST_CALL stores its own location into T0 and jumps into the finally block at L3. When FAST_RET is reached, it jumps back to (one after) the location stored in T0. In this case this would be L2, which is just a jump around the finally block. This is the base case where no special control flow (returns or exceptions) occurs. Let’s now consider the exceptional case: try { throw new Exception ( "try" ); } catch ( Exception $e ) { throw new Exception ( "catch" ); } finally { throw new Exception ( "finally" ); } When handling an exception, we have to consider the position of the thrown exception relative to the closest surrounding try/catch/finally block: Throw from try, with matching catch: Populate $e and jump into catch. Throw from catch or try without matching catch, if there is a finally block: Jump into finally block and this time back up the exception into the FAST_CALL temporary (instead of storing the return address there.) Throw from finally: If there is a backed-up exception in the FAST_CALL temporary, chain it as the previous exception of the thrown one. Continue bubbling the exception up to the next try/catch/finally. Otherwise: Continue bubbling the exception up to the next try/catch/finally. In this example we’ll go through the first three steps: First try throws, triggering a jump into catch. Catch also throws, triggering a jump into the finally block, with the exception backed up in the FAST_CALL temporary. The finally block then also throws, so that the “finally” exception will bubble up with the “catch” exception set as its previous exception. A small variation on the previous example is the following code: try { try { throw new Exception ( "try" ); } finally {} } catch ( Exception $e ) { try { throw new Exception ( "catch" ); } finally {} } finally { try { throw new Exception ( "finally" ); } finally {} } All the inner finally blocks here are entered exceptionally, but left normally (via FAST_RET). In this case the previously described exception handling procedure is resumed starting from the parent try/catch/finally block. This parent try/catch is stored in the FAST_RET opcode (here “try-catch(0)”). This essentially covers the interaction of finally and exceptions. But what about a return in finally? try { throw new Exception ( "try" ); } finally { return 42 ; } The relevant portion of the opcode sequence is this: L4: T0 = FAST_CALL ->L6 L5: JMP ->L9 L6: DISCARD_EXCEPTION T0 L7: RETURN 42 L8: FAST_RET T0 The additional DISCARD_EXCEPTION opcode is responsible for discarding the exception thrown in the try block (remember: the return in the finally wins). What about a return in try? try { $a = 42 ; return $a ; } finally { ++ $a ; } The excepted return value here is 42, not 43. The return value is determined by the return $a line, any further modification of $a should not matter. The code results in: L0: ASSIGN $a, 42 L1: T3 = QM_ASSIGN $a L2: T1 = FAST_CALL ->L6, T3 L3: RETURN T3 L4: T1 = FAST_CALL ->L6 # unreachable L5: JMP ->L8 # unreachable L6: PRE_INC $a L7: FAST_RET T1 L8: RETURN null Two of the opcodes are unreachable, as they occur directly after a return. These will be removed during optimization, but I’m showing unoptimized opcodes here. There are two interesting things here: Firstly, $a is copied into T3 using QM_ASSIGN (which is basically a “copy into temporary” instruction). This is what prevents the later modification of $a from affecting the return value. Secondly, T3 is also passed to FAST_CALL, which will back up the value in T1. If the return from the try block is later discarded (e.g, because finally throws or returns), this mechanism will be used to free the unused return value. All of these individual mechanisms are simple, but some care needs to taken when they are composed. Consider the following example, where Dtor is again some Traversable class with a throwing destructor: try { foreach ( new Dtor as $v ) { try { return 1 ; } finally { return 2 ; } } } finally { echo "finally" ; } This code generates the following opcodes: L0: V2 = NEW (0 args) "Dtor" L1: DO_FCALL L2: V4 = FE_RESET_R V2 ->L16 L3: FE_FETCH_R V4 $v ->L16 L4: T5 = FAST_CALL ->L10 # inner try L5: FE_FREE (free on return) V4 L6: T1 = FAST_CALL ->L19 L7: RETURN 1 L8: T5 = FAST_CALL ->L10 # unreachable L9: JMP ->L15 L10: DISCARD_EXCEPTION T5 # inner finally L11: FE_FREE (free on return) V4 L12: T1 = FAST_CALL ->L19 L13: RETURN 2 L14: FAST_RET T5 try-catch(0) L15: JMP ->L3 L16: FE_FREE V4 L17: T1 = FAST_CALL ->L19 L18: JMP ->L21 L19: ECHO "finally" # outer finally L20: FAST_RET T1 The sequence for the first return (from inner try) is FAST_CALL L10, FE_FREE V4, FAST_CALL L19, RETURN. This will first call into the inner finally block, then free the foreach loop variable, then call into the outer finally block and then return. The sequence for the second return (from inner finally) is DISCARD_EXCEPTION T5, FE_FREE V4, FAST_CALL L19. This first discards the exception (or here: return value) of the inner try block, then frees the foreach loop variable and finally calls into the outer finally block. Note how in both cases the order of these instructions is the reverse order of the relevant blocks in the source code. Generators Generator functions may be paused and resumed, and consequently require special VM stack management. Here’s a simple generator: function gen ( $x ) { foo ( yield $x ); } This yields the following opcodes: $x = RECV 1 GENERATOR_CREATE INIT_FCALL_BY_NAME (1 args) string("foo") V1 = YIELD $x SEND_VAR_NO_REF_EX V1 1 DO_FCALL_BY_NAME GENERATOR_RETURN null Until GENERATOR_CREATE is reached, this is executed as a normal function, on the normal VM stack. GENERATOR_CREATE then creates a Generator object, as well as a heap-allocated execute_data structure (including slots for variables and arguments, as usual), into which the execute_data on the VM stack is copied. When the generator is resumed again, the executor will use the heap-allocated execute_data, but will continue to use the main VM stack to push call frames. An obvious problem with this is that it’s possible to interrupt a generator while a call is in progress, as the previous example shows. Here the YIELD is executed at a point where the call frame for the call foo() has already been pushed onto the VM stack. This relatively uncommon case is handled by copying the active call frames into the generator structure when control is yielded, and restoring them when the generator is resumed. This design is used since PHP 7.1. Previously, each generator had its own 4KiB VM page, which would be swapped into the executor when a generator was restored. This avoids the need for copying call frames, but increases memory usage. Smart branches It is very common that comparison instructions are directly followed by condition jumps. For example: L0: T2 = IS_EQUAL $a, $b L1: JMPZ T2 ->L3 L2: ECHO "equal" Because this pattern is so common, all the comparison opcodes (such as IS_EQUAL) implement a smart branch mechanism: they check if the next instruction is a JMPZ or JMPNZ instruction and if so, perform the respective jump operation themselves. The smart branch mechanism only checks whether the next instruction is a JMPZ/JMPNZ, but does not actually check whether its operand is actually the result of the comparison, or something else. This requires special care in cases where the comparison and subsequent jump are unrelated. For example, the code ($a == $b) + ($d ? $e : $f) generates: L0: T5 = IS_EQUAL $a, $b L1: NOP L2: JMPZ $d ->L5 L3: T6 = QM_ASSIGN $e L4: JMP ->L6 L5: T6 = QM_ASSIGN $f L6: T7 = ADD T5 T6 L7: FREE T7 Note that a NOP has been inserted between the IS_EQUAL and the JMPZ. If this NOP weren’t present, the branch would end up using the IS_EQUAL result, rather than the JMPZ operand. Runtime cache Because opcode arrays are shared (without locks) between multiple processes, they are strictly immutable. However, runtime values may be cached in a separate “runtime cache”, which is basically an array of pointers. Literals may have an associated runtime cache entry (or more than one), which is stored in their u2 slot. Runtime cache entries come in two types: The first are ordinary cache entries, such as the one used by INIT_FCALL. After INIT_FCALL has looked up the called function once (based on its name), the function pointer will be cached in the associated runtime cache slot. The second type are polymorphic cache entries, which are just two consecutive cache slots, where the first stores a class entry and the second the actual datum. These are used for operations like FETCH_OBJ_R, where the offset of the property in the property table for a certain class is cached. If the next access happens on the same class (which is quite likely), the cached value will be used. Otherwise a more expensive lookup operation is performed, and the result is cached for the new class entry. VM interrupts Prior to PHP 7.0, execution timeouts used to be handled by a longjump into the shutdown sequence directly from the signal handler. As you may imagine, this caused all manner of unpleasantness. Since PHP 7.0 timeouts are instead delayed until control returns to the virtual machine. If it doesn’t return within a certain grace period, the process is aborted. Since PHP 7.1 pcntl signal handlers use the same mechanism as execution timeouts. When a signal is pending, a VM interrupt flag is set and this flag is checked by the virtual machine at certain points. A check is not performed at every instruction, but rather only on jumps and calls. As such the interrupt will not be handled immediately on return to the VM, but rather at the end of the current section of linear control flow. Specialization If you take a look at the VM definition file, you’ll find that opcode handlers are defined as follows: ZEND_VM_HANDLER(1, ZEND_ADD, CONST\|TMPVAR\|CV, CONST\|TMPVAR\|CV) The 1 here is the opcode number, ZEND_ADD its name, while the other two arguments specify which operand types the instruction accepts. The generated virtual machine code (generated by zend_vm_gen.php ) will then contain specialized handlers for each of the possible operand type combinations. These will have names like ZEND_ADD_SPEC_CONST_CONST_HANDLER. The specialized handlers are generated by replacing certain macros in the handler body. The obvious ones are OP1_TYPE and OP2_TYPE, but operations such as GET_OP1_ZVAL_PTR() and FREE_OP1() are also specialized. The handler for ADD specified that it accepts CONST\|TMPVAR\|CV operands. The TMPVAR here means that the opcode accepts both TMPs and VARs, but asks for these to not be specialized separately. Remember that for most purposes the only difference between TMP and VAR is that the latter can contain references. For an opcode like ADD (where references are on the slow-path anyway) having a separate specialization for this is not worthwhile. Some other opcodes that do make this distinction will use TMP\|VAR in their operand list. Next to the operand-type based specialization, handlers can also be specialized on other factors, such as whether their return value is used. ASSIGN_DIM specializes based on the operand type of the following OP_DATA opcode: ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR\|CV, CONST\|TMPVAR\|UNUSED\|NEXT\|CV, SPEC(OP_DATA=CONST\|TMP\|VAR\|CV)) Based on this signature, 244=32 different variants of ASSIGN_DIM will be generated. The specification for the second operand also contains an entry for NEXT . This is not related to specialization, instead it specifies what the meaning of an UNUSED operand is in this context: it means that this is an append operations ( $arr[] ). Another example: ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR\|UNUSED\|THIS\|CV, CONST\|TMPVAR\|UNUSED\|NEXT\|CV, DIM_OBJ, SPEC(DIM_OBJ)) Here we have that the first operand being UNUSED implies an access on $this . This is a general convention for object related opcodes, for example FETCH_OBJ_R UNUSED, 'prop' corresponds to $this->prop . An UNUSED second operand again implies an append operation. The third argument here specifies the meaning of the extended_value operand: It contains a flag that distinguishes between $a += 1 , $a[$b] += 1 and $a->b += 1 . Finally, the SPEC(DIM_OBJ) instructs that a specialized handler should be generated for each of those. (In this case the number of total handlers that will be generated is non-trivial, because the VM generator knows that certain combination are impossible. For example an UNUSED op1 is only relevant for the OBJ case, etc.) Finally, the virtual machine generator supports an additional, more sophisticated specialization mechanism. Towards the end of the definition file, you will find a number of handlers of this form: ZEND_VM_TYPE_SPEC_HANDLER( ZEND_ADD, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG), ZEND_ADD_LONG_NO_OVERFLOW, CONST\|TMPVARCV, CONST\|TMPVARCV, SPEC(NO_CONST_CONST,COMMUTATIVE) ) These handlers specialize not only based on the VM operand type, but also based on the possible types the operand might take at runtime. The mechanism by which possible operand types are determined is part of the opcache optimization infrastructure and quite outside the scope of this article. However, assuming such information is available, it should be clear that this is a handler for an addition of the form int + int -> int . Additionally, the SPEC annotation tells the specializer that variants for two const operands should not be generated and that the operation is commutative, so that if we already have a CONST+TMPVARCV specialization, we do not need to generate TMPVARCV+CONST as well. Fast-path / slow-path split Many opcode handlers are implemented using a fast-path / slow-path split, where first a few common cases are handled, before falling back to a generic implementation. It’s about time we looked at some actual code, so I’ll just paste the entirety of the SL (shift-left) implementation here: ZEND_VM_HANDLER ( 6 , ZEND_SL , CONST \| TMPVAR \| CV , CONST \| TMPVAR \| CV ) { USE_OPLINE zend_free_op free_op1 , free_op2 ; zval * op1 , * op2 ; op1 = GET_OP1_ZVAL_PT	2026-01-13T08:49:46
https://docs.python.org/3/whatsnew/3.14.html#whatsnew314-color-json	What’s new in Python 3.14 — Python 3.14.2 documentation Theme Auto Light Dark Table of Contents What’s new in Python 3.14 Summary – Release highlights New features PEP 649 & PEP 749 : Deferred evaluation of annotations PEP 734 : Multiple interpreters in the standard library PEP 750 : Template string literals PEP 768 : Safe external debugger interface A new type of interpreter Free-threaded mode improvements Improved error messages PEP 784 : Zstandard support in the standard library Asyncio introspection capabilities Concurrent safe warnings control Other language changes Built-ins Command line and environment PEP 758: Allow except and except* expressions without brackets PEP 765: Control flow in finally blocks Incremental garbage collection Default interactive shell New modules Improved modules argparse ast asyncio calendar concurrent.futures configparser contextvars ctypes curses datetime decimal difflib dis errno faulthandler fnmatch fractions functools getopt getpass graphlib heapq hmac http imaplib inspect io json linecache logging.handlers math mimetypes multiprocessing operator os os.path pathlib pdb pickle platform pydoc re socket ssl struct symtable sys sys.monitoring sysconfig tarfile threading tkinter turtle types typing unicodedata unittest urllib uuid webbrowser zipfile Optimizations asyncio base64 bdb difflib gc io pathlib pdb textwrap uuid zlib Removed argparse ast asyncio email importlib.abc itertools pathlib pkgutil pty sqlite3 urllib Deprecated New deprecations Pending removal in Python 3.15 Pending removal in Python 3.16 Pending removal in Python 3.17 Pending removal in Python 3.18 Pending removal in Python 3.19 Pending removal in future versions CPython bytecode changes Pseudo-instructions C API changes Python configuration C API New features in the C API Limited C API changes Removed C APIs Deprecated C APIs Pending removal in Python 3.15 Pending removal in Python 3.16 Pending removal in Python 3.18 Pending removal in future versions Build changes build-details.json Discontinuation of PGP signatures Free-threaded Python is officially supported Binary releases for the experimental just-in-time compiler Porting to Python 3.14 Changes in the Python API Changes in annotations ( PEP 649 and PEP 749 ) Implications for annotated code Implications for readers of __annotations__ Related changes from __future__ import annotations Changes in the C API Notable changes in 3.14.1 Previous topic What’s New in Python Next topic What’s New In Python 3.13 This page Report a bug Show source Navigation index modules \| next \| previous \| Python » 3.14.2 Documentation » What’s New in Python » What’s new in Python 3.14 \| Theme Auto Light Dark \| What’s new in Python 3.14 ¶ Editors : Adam Turner and Hugo van Kemenade This article explains the new features in Python 3.14, compared to 3.13. Python 3.14 was released on 7 October 2025. For full details, see the changelog . See also PEP 745 – Python 3.14 release schedule Summary – Release highlights ¶ Python 3.14 is the latest stable release of the Python programming language, with a mix of changes to the language, the implementation, and the standard library. The biggest changes include template string literals , deferred evaluation of annotations , and support for subinterpreters in the standard library. The library changes include significantly improved capabilities for introspection in asyncio , support for Zstandard via a new compression.zstd module, syntax highlighting in the REPL, as well as the usual deprecations and removals, and improvements in user-friendliness and correctness. This article doesn’t attempt to provide a complete specification of all new features, but instead gives a convenient overview. For full details refer to the documentation, such as the Library Reference and Language Reference . To understand the complete implementation and design rationale for a change, refer to the PEP for a particular new feature; but note that PEPs usually are not kept up-to-date once a feature has been fully implemented. See Porting to Python 3.14 for guidance on upgrading from earlier versions of Python. Interpreter improvements: PEP 649 and PEP 749 : Deferred evaluation of annotations PEP 734 : Multiple interpreters in the standard library PEP 750 : Template strings PEP 758 : Allow except and except* expressions without brackets PEP 765 : Control flow in finally blocks PEP 768 : Safe external debugger interface for CPython A new type of interpreter Free-threaded mode improvements Improved error messages Incremental garbage collection Significant improvements in the standard library: PEP 784 : Zstandard support in the standard library Asyncio introspection capabilities Concurrent safe warnings control Syntax highlighting in the default interactive shell , and color output in several standard library CLIs C API improvements: PEP 741 : Python configuration C API Platform support: PEP 776 : Emscripten is now an officially supported platform , at tier 3 . Release changes: PEP 779 : Free-threaded Python is officially supported PEP 761 : PGP signatures have been discontinued for official releases Windows and macOS binary releases now support the experimental just-in-time compiler Binary releases for Android are now provided New features ¶ PEP 649 & PEP 749 : Deferred evaluation of annotations ¶ The annotations on functions, classes, and modules are no longer evaluated eagerly. Instead, annotations are stored in special-purpose annotate functions and evaluated only when necessary (except if from __future__ import annotations is used). This change is designed to improve performance and usability of annotations in Python in most circumstances. The runtime cost for defining annotations is minimized, but it remains possible to introspect annotations at runtime. It is no longer necessary to enclose annotations in strings if they contain forward references. The new annotationlib module provides tools for inspecting deferred annotations. Annotations may be evaluated in the VALUE format (which evaluates annotations to runtime values, similar to the behavior in earlier Python versions), the FORWARDREF format (which replaces undefined names with special markers), and the STRING format (which returns annotations as strings). This example shows how these formats behave: >>> from annotationlib import get_annotations , Format >>> def func ( arg : Undefined ): ... pass >>> get_annotations ( func , format = Format . VALUE ) Traceback (most recent call last): ... NameError : name 'Undefined' is not defined >>> get_annotations ( func , format = Format . FORWARDREF ) {'arg': ForwardRef('Undefined', owner=<function func at 0x...>)} >>> get_annotations ( func , format = Format . STRING ) {'arg': 'Undefined'} The porting section contains guidance on changes that may be needed due to these changes, though in the majority of cases, code will continue working as-is. (Contributed by Jelle Zijlstra in PEP 749 and gh-119180 ; PEP 649 was written by Larry Hastings.) See also PEP 649 Deferred Evaluation Of Annotations Using Descriptors PEP 749 Implementing PEP 649 PEP 734 : Multiple interpreters in the standard library ¶ The CPython runtime supports running multiple copies of Python in the same process simultaneously and has done so for over 20 years. Each of these separate copies is called an ‘interpreter’. However, the feature had been available only through the C-API . That limitation is removed in Python 3.14, with the new concurrent.interpreters module. There are at least two notable reasons why using multiple interpreters has significant benefits: they support a new (to Python), human-friendly concurrency model true multi-core parallelism For some use cases, concurrency in software improves efficiency and can simplify design, at a high level. At the same time, implementing and maintaining all but the simplest concurrency is often a struggle for the human brain. That especially applies to plain threads (for example, threading ), where all memory is shared between all threads. With multiple isolated interpreters, you can take advantage of a class of concurrency models, like Communicating Sequential Processes (CSP) or the actor model, that have found success in other programming languages, like Smalltalk, Erlang, Haskell, and Go. Think of multiple interpreters as threads but with opt-in sharing. Regarding multi-core parallelism: as of Python 3.12, interpreters are now sufficiently isolated from one another to be used in parallel (see PEP 684 ). This unlocks a variety of CPU-intensive use cases for Python that were limited by the GIL . Using multiple interpreters is similar in many ways to multiprocessing , in that they both provide isolated logical “processes” that can run in parallel, with no sharing by default. However, when using multiple interpreters, an application will use fewer system resources and will operate more efficiently (since it stays within the same process). Think of multiple interpreters as having the isolation of processes with the efficiency of threads. While the feature has been around for decades, multiple interpreters have not been used widely, due to low awareness and the lack of a standard library module. Consequently, they currently have several notable limitations, which are expected to improve significantly now that the feature is going mainstream. Current limitations: starting each interpreter has not been optimized yet each interpreter uses more memory than necessary (work continues on extensive internal sharing between interpreters) there aren’t many options yet for truly sharing objects or other data between interpreters (other than memoryview ) many third-party extension modules on PyPI are not yet compatible with multiple interpreters (all standard library extension modules are compatible) the approach to writing applications that use multiple isolated interpreters is mostly unfamiliar to Python users, for now The impact of these limitations will depend on future CPython improvements, how interpreters are used, and what the community solves through PyPI packages. Depending on the use case, the limitations may not have much impact, so try it out! Furthermore, future CPython releases will reduce or eliminate overhead and provide utilities that are less appropriate on PyPI. In the meantime, most of the limitations can also be addressed through extension modules, meaning PyPI packages can fill any gap for 3.14, and even back to 3.12 where interpreters were finally properly isolated and stopped sharing the GIL . Likewise, libraries on PyPI are expected to emerge for high-level abstractions on top of interpreters. Regarding extension modules, work is in progress to update some PyPI projects, as well as tools like Cython, pybind11, nanobind, and PyO3. The steps for isolating an extension module are found at Isolating Extension Modules . Isolating a module has a lot of overlap with what is required to support free-threading , so the ongoing work in the community in that area will help accelerate support for multiple interpreters. Also added in 3.14: concurrent.futures.InterpreterPoolExecutor . (Contributed by Eric Snow in gh-134939 .) See also PEP 734 PEP 750 : Template string literals ¶ Template strings are a new mechanism for custom string processing. They share the familiar syntax of f-strings but, unlike f-strings, return an object representing the static and interpolated parts of the string, instead of a simple str . To write a t-string, use a 't' prefix instead of an 'f' : >>> variety = 'Stilton' >>> template = t 'Try some {variety} cheese!' >>> type ( template ) <class 'string.templatelib.Template'> Template objects provide access to the static and interpolated (in curly braces) parts of a string before they are combined. Iterate over Template instances to access their parts in order: >>> list ( template ) ['Try some ', Interpolation('Stilton', 'variety', None, ''), ' cheese!'] It’s easy to write (or call) code to process Template instances. For example, here’s a function that renders static parts lowercase and Interpolation instances uppercase: from string.templatelib import Interpolation def lower_upper ( template ): """Render static parts lowercase and interpolations uppercase.""" parts = [] for part in template : if isinstance ( part , Interpolation ): parts . append ( str ( part . value ) . upper ()) else : parts . append ( part . lower ()) return '' . join ( parts ) name = 'Wenslydale' template = t 'Mister {name} ' assert lower_upper ( template ) == 'mister WENSLYDALE' Because Template instances distinguish between static strings and interpolations at runtime, they can be useful for sanitising user input. Writing a html() function that escapes user input in HTML is an exercise left to the reader! Template processing code can provide improved flexibility. For instance, a more advanced html() function could accept a dict of HTML attributes directly in the template: attributes = { 'src' : 'limburger.jpg' , 'alt' : 'lovely cheese' } template = t '<img {attributes} >' assert html ( template ) == '<img src="limburger.jpg" alt="lovely cheese" />' Of course, template processing code does not need to return a string-like result. An even more advanced html() could return a custom type representing a DOM-like structure. With t-strings in place, developers can write systems that sanitise SQL, make safe shell operations, improve logging, tackle modern ideas in web development (HTML, CSS, and so on), and implement lightweight custom business DSLs. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in gh-132661 .) See also PEP 750 . PEP 768 : Safe external debugger interface ¶ Python 3.14 introduces a zero-overhead debugging interface that allows debuggers and profilers to safely attach to running Python processes without stopping or restarting them. This is a significant enhancement to Python’s debugging capabilities, meaning that unsafe alternatives are no longer required. The new interface provides safe execution points for attaching debugger code without modifying the interpreter’s normal execution path or adding any overhead at runtime. Due to this, tools can now inspect and interact with Python applications in real-time, which is a crucial capability for high-availability systems and production environments. For convenience, this interface is implemented in the sys.remote_exec() function. For example: import sys from tempfile import NamedTemporaryFile with NamedTemporaryFile ( mode = 'w' , suffix = '.py' , delete = False ) as f : script_path = f . name f . write ( f 'import my_debugger; my_debugger.connect( { os . getpid () } )' ) # Execute in process with PID 1234 print ( 'Behold! An offering:' ) sys . remote_exec ( 1234 , script_path ) This function allows sending Python code to be executed in a target process at the next safe execution point. However, tool authors can also implement the protocol directly as described in the PEP, which details the underlying mechanisms used to safely attach to running processes. The debugging interface has been carefully designed with security in mind and includes several mechanisms to control access: A PYTHON_DISABLE_REMOTE_DEBUG environment variable. A -X disable-remote-debug command-line option. A --without-remote-debug configure flag to completely disable the feature at build time. (Contributed by Pablo Galindo Salgado, Matt Wozniski, and Ivona Stojanovic in gh-131591 .) See also PEP 768 . A new type of interpreter ¶ A new type of interpreter has been added to CPython. It uses tail calls between small C functions that implement individual Python opcodes, rather than one large C case statement. For certain newer compilers, this interpreter provides significantly better performance. Preliminary benchmarks suggest a geometric mean of 3-5% faster on the standard pyperformance benchmark suite, depending on platform and architecture. The baseline is Python 3.14 built with Clang 19, without this new interpreter. This interpreter currently only works with Clang 19 and newer on x86-64 and AArch64 architectures. However, a future release of GCC is expected to support this as well. This feature is opt-in for now. Enabling profile-guided optimization is highly recommendeded when using the new interpreter as it is the only configuration that has been tested and validated for improved performance. For further information, see --with-tail-call-interp . Note This is not to be confused with tail call optimization of Python functions, which is currently not implemented in CPython. This new interpreter type is an internal implementation detail of the CPython interpreter. It doesn’t change the visible behavior of Python programs at all. It can improve their performance, but doesn’t change anything else. (Contributed by Ken Jin in gh-128563 , with ideas on how to implement this in CPython by Mark Shannon, Garrett Gu, Haoran Xu, and Josh Haberman.) Free-threaded mode improvements ¶ CPython’s free-threaded mode ( PEP 703 ), initially added in 3.13, has been significantly improved in Python 3.14. The implementation described in PEP 703 has been finished, including C API changes, and temporary workarounds in the interpreter were replaced with more permanent solutions. The specializing adaptive interpreter ( PEP 659 ) is now enabled in free-threaded mode, which along with many other optimizations greatly improves its performance. The performance penalty on single-threaded code in free-threaded mode is now roughly 5-10%, depending on the platform and C compiler used. From Python 3.14, when compiling extension modules for the free-threaded build of CPython on Windows, the preprocessor variable Py_GIL_DISABLED now needs to be specified by the build backend, as it will no longer be determined automatically by the C compiler. For a running interpreter, the setting that was used at compile time can be found using sysconfig.get_config_var() . The new -X context_aware_warnings flag controls if concurrent safe warnings control is enabled. The flag defaults to true for the free-threaded build and false for the GIL-enabled build. A new thread_inherit_context flag has been added, which if enabled means that threads created with threading.Thread start with a copy of the Context() of the caller of start() . Most significantly, this makes the warning filtering context established by catch_warnings be “inherited” by threads (or asyncio tasks) started within that context. It also affects other modules that use context variables, such as the decimal context manager. This flag defaults to true for the free-threaded build and false for the GIL-enabled build. (Contributed by Sam Gross, Matt Page, Neil Schemenauer, Thomas Wouters, Donghee Na, Kirill Podoprigora, Ken Jin, Itamar Oren, Brett Simmers, Dino Viehland, Nathan Goldbaum, Ralf Gommers, Lysandros Nikolaou, Kumar Aditya, Edgar Margffoy, and many others. Some of these contributors are employed by Meta, which has continued to provide significant engineering resources to support this project.) Improved error messages ¶ The interpreter now provides helpful suggestions when it detects typos in Python keywords. When a word that closely resembles a Python keyword is encountered, the interpreter will suggest the correct keyword in the error message. This feature helps programmers quickly identify and fix common typing mistakes. For example: >>> whille True : ... pass Traceback (most recent call last): File "<stdin>" , line 1 whille True : ^^^^^^ SyntaxError : invalid syntax. Did you mean 'while'? While the feature focuses on the most common cases, some variations of misspellings may still result in regular syntax errors. (Contributed by Pablo Galindo in gh-132449 .) elif statements that follow an else block now have a specific error message. (Contributed by Steele Farnsworth in gh-129902 .) >>> if who == "me" : ... print ( "It's me!" ) ... else : ... print ( "It's not me!" ) ... elif who is None : ... print ( "Who is it?" ) File "<stdin>", line 5 elif who is None: ^^^^ SyntaxError: 'elif' block follows an 'else' block If a statement is passed to the Conditional expressions after else , or one of pass , break , or continue is passed before if , then the error message highlights where the expression is required. (Contributed by Sergey Miryanov in gh-129515 .) >>> x = 1 if True else pass Traceback (most recent call last): File "<string>" , line 1 x = 1 if True else pass ^^^^ SyntaxError : expected expression after 'else', but statement is given >>> x = continue if True else break Traceback (most recent call last): File "<string>" , line 1 x = continue if True else break ^^^^^^^^ SyntaxError : expected expression before 'if', but statement is given When incorrectly closed strings are detected, the error message suggests that the string may be intended to be part of the string. (Contributed by Pablo Galindo in gh-88535 .) >>> "The interesting object " The important object " is very important" Traceback (most recent call last): SyntaxError : invalid syntax. Is this intended to be part of the string? When strings have incompatible prefixes, the error now shows which prefixes are incompatible. (Contributed by Nikita Sobolev in gh-133197 .) >>> ub 'abc' File "<python-input-0>" , line 1 ub 'abc' ^^ SyntaxError : 'u' and 'b' prefixes are incompatible Improved error messages when using as with incompatible targets in: Imports: import ... as ... From imports: from ... import ... as ... Except handlers: except ... as ... Pattern-match cases: case ... as ... (Contributed by Nikita Sobolev in gh-123539 , gh-123562 , and gh-123440 .) Improved error message when trying to add an instance of an unhashable type to a dict or set . (Contributed by CF Bolz-Tereick and Victor Stinner in gh-132828 .) >>> s = set () >>> s . add ({ 'pages' : 12 , 'grade' : 'A' }) Traceback (most recent call last): File "<python-input-1>" , line 1 , in <module> s . add ({ 'pages' : 12 , 'grade' : 'A' }) ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError : cannot use 'dict' as a set element (unhashable type: 'dict') >>> d = {} >>> l = [ 1 , 2 , 3 ] >>> d [ l ] = 12 Traceback (most recent call last): File "<python-input-4>" , line 1 , in <module> d [ l ] = 12 ~^^^ TypeError : cannot use 'list' as a dict key (unhashable type: 'list') Improved error message when an object supporting the synchronous context manager protocol is entered using async with instead of with , and vice versa for the asynchronous context manager protocol. (Contributed by Bénédikt Tran in gh-128398 .) PEP 784 : Zstandard support in the standard library ¶ The new compression package contains modules compression.lzma , compression.bz2 , compression.gzip and compression.zlib which re-export the lzma , bz2 , gzip and zlib modules respectively. The new import names under compression are the preferred names for importing these compression modules from Python 3.14. However, the existing modules names have not been deprecated. Any deprecation or removal of the existing compression modules will occur no sooner than five years after the release of 3.14. The new compression.zstd module provides compression and decompression APIs for the Zstandard format via bindings to Meta’s zstd library . Zstandard is a widely adopted, highly efficient, and fast compression format. In addition to the APIs introduced in compression.zstd , support for reading and writing Zstandard compressed archives has been added to the tarfile , zipfile , and shutil modules. Here’s an example of using the new module to compress some data: from compression import zstd import math data = str ( math . pi ) . encode () * 20 compressed = zstd . compress ( data ) ratio = len ( compressed ) / len ( data ) print ( f "Achieved compression ratio of { ratio } " ) As can be seen, the API is similar to the APIs of the lzma and bz2 modules. (Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in gh-132983 .) See also PEP 784 . Asyncio introspection capabilities ¶ Added a new command-line interface to inspect running Python processes using asynchronous tasks, available via python -m asyncio ps PID or python -m asyncio pstree PID . The ps subcommand inspects the given process ID (PID) and displays information about currently running asyncio tasks. It outputs a task table: a flat listing of all tasks, their names, their coroutine stacks, and which tasks are awaiting them. The pstree subcommand fetches the same information, but instead renders a visual async call tree, showing coroutine relationships in a hierarchical format. This command is particularly useful for debugging long-running or stuck asynchronous programs. It can help developers quickly identify where a program is blocked, what tasks are pending, and how coroutines are chained together. For example given this code: import asyncio async def play_track ( track ): await asyncio . sleep ( 5 ) print ( f '🎵 Finished: { track } ' ) async def play_album ( name , tracks ): async with asyncio . TaskGroup () as tg : for track in tracks : tg . create_task ( play_track ( track ), name = track ) async def main (): async with asyncio . TaskGroup () as tg : tg . create_task ( play_album ( 'Sundowning' , [ 'TNDNBTG' , 'Levitate' ]), name = 'Sundowning' ) tg . create_task ( play_album ( 'TMBTE' , [ 'DYWTYLM' , 'Aqua Regia' ]), name = 'TMBTE' ) if __name__ == '__main__' : asyncio . run ( main ()) Executing the new tool on the running process will yield a table like this: python -m asyncio ps 12345 tid task id task name coroutine stack awaiter chain awaiter name awaiter id ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 1935500 0x7fc930c18050 Task-1 TaskGroup._aexit -> TaskGroup.__aexit__ -> main 0x0 1935500 0x7fc930c18230 Sundowning TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> main Task-1 0x7fc930c18050 1935500 0x7fc93173fa50 TMBTE TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> main Task-1 0x7fc930c18050 1935500 0x7fc93173fdf0 TNDNBTG sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album Sundowning 0x7fc930c18230 1935500 0x7fc930d32510 Levitate sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album Sundowning 0x7fc930c18230 1935500 0x7fc930d32890 DYWTYLM sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album TMBTE 0x7fc93173fa50 1935500 0x7fc93161ec30 Aqua Regia sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album TMBTE 0x7fc93173fa50 or a tree like this: python -m asyncio pstree 12345 └── ( T ) Task-1 └── main example.py:13 └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 ├── ( T ) Sundowning │ └── album example.py:8 │ └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 │ └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 │ ├── ( T ) TNDNBTG │ │ └── play example.py:4 │ │ └── sleep Lib/asyncio/tasks.py:702 │ └── ( T ) Levitate │ └── play example.py:4 │ └── sleep Lib/asyncio/tasks.py:702 └── ( T ) TMBTE └── album example.py:8 └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 ├── ( T ) DYWTYLM │ └── play example.py:4 │ └── sleep Lib/asyncio/tasks.py:702 └── ( T ) Aqua Regia └── play example.py:4 └── sleep Lib/asyncio/tasks.py:702 If a cycle is detected in the async await graph (which could indicate a programming issue), the tool raises an error and lists the cycle paths that prevent tree construction: python -m asyncio pstree 12345 ERROR: await-graph contains cycles - cannot print a tree! cycle: Task-2 → Task-3 → Task-2 (Contributed by Pablo Galindo, Łukasz Langa, Yury Selivanov, and Marta Gomez Macias in gh-91048 .) Concurrent safe warnings control ¶ The warnings.catch_warnings context manager will now optionally use a context variable for warning filters. This is enabled by setting the context_aware_warnings flag, either with the -X command-line option or an environment variable. This gives predictable warnings control when using catch_warnings combined with multiple threads or asynchronous tasks. The flag defaults to true for the free-threaded build and false for the GIL-enabled build. (Contributed by Neil Schemenauer and Kumar Aditya in gh-130010 .) Other language changes ¶ All Windows code pages are now supported as ‘cpXXX’ codecs on Windows. (Contributed by Serhiy Storchaka in gh-123803 .) Implement mixed-mode arithmetic rules combining real and complex numbers as specified by the C standard since C99. (Contributed by Sergey B Kirpichev in gh-69639 .) More syntax errors are now detected regardless of optimisation and the -O command-line option. This includes writes to __debug__ , incorrect use of await , and asynchronous comprehensions outside asynchronous functions. For example, python -O -c 'assert (__debug__ := 1)' or python -O -c 'assert await 1' now produce SyntaxError s. (Contributed by Irit Katriel and Jelle Zijlstra in gh-122245 & gh-121637 .) When subclassing a pure C type, the C slots for the new type are no longer replaced with a wrapped version on class creation if they are not explicitly overridden in the subclass. (Contributed by Tomasz Pytel in gh-132284 .) Built-ins ¶ The bytes.fromhex() and bytearray.fromhex() methods now accept ASCII bytes and bytes-like objects . (Contributed by Daniel Pope in gh-129349 .) Add class methods float.from_number() and complex.from_number() to convert a number to float or complex type correspondingly. They raise a TypeError if the argument is not a real number. (Contributed by Serhiy Storchaka in gh-84978 .) Support underscore and comma as thousands separators in the fractional part for floating-point presentation types of the new-style string formatting (with format() or f-strings ). (Contributed by Sergey B Kirpichev in gh-87790 .) The int() function no longer delegates to __trunc__() . Classes that want to support conversion to int() must implement either __int__() or __index__() . (Contributed by Mark Dickinson in gh-119743 .) The map() function now has an optional keyword-only strict flag like zip() to check that all the iterables are of equal length. (Contributed by Wannes Boeykens in gh-119793 .) The memoryview type now supports subscription, making it a generic type . (Contributed by Brian Schubert in gh-126012 .) Using NotImplemented in a boolean context will now raise a TypeError . This has raised a DeprecationWarning since Python 3.9. (Contributed by Jelle Zijlstra in gh-118767 .) Three-argument pow() now tries calling __rpow__() if necessary. Previously it was only called in two-argument pow() and the binary power operator. (Contributed by Serhiy Storchaka in gh-130104 .) super objects are now copyable and pickleable . (Contributed by Serhiy Storchaka in gh-125767 .) Command line and environment ¶ The import time flag can now track modules that are already loaded (‘cached’), via the new -X importtime=2 . When such a module is imported, the self and cumulative times are replaced by the string cached . Values above 2 for -X importtime are now reserved for future use. (Contributed by Noah Kim and Adam Turner in gh-118655 .) The command-line option -c now automatically dedents its code argument before execution. The auto-dedentation behavior mirrors textwrap.dedent() . (Contributed by Jon Crall and Steven Sun in gh-103998 .) -J is no longer a reserved flag for Jython , and now has no special meaning. (Contributed by Adam Turner in gh-133336 .) PEP 758: Allow except and except* expressions without brackets ¶ The except and except* expressions now allow brackets to be omitted when there are multiple exception types and the as clause is not used. For example: try : connect_to_server () except TimeoutError , ConnectionRefusedError : print ( 'The network has ceased to be!' ) (Contributed by Pablo Galindo and Brett Cannon in PEP 758 and gh-131831 .) PEP 765: Control flow in finally blocks ¶ The compiler now emits a SyntaxWarning when a return , break , or continue statement have the effect of leaving a finally block. This change is specified in PEP 765 . In situations where this change is inconvenient (such as those where the warnings are redundant due to code linting), the warning filter can be used to turn off all syntax warnings by adding ignore::SyntaxWarning as a filter. This can be specified in combination with a filter that converts other warnings to errors (for example, passing -Werror -Wignore::SyntaxWarning as CLI options, or setting PYTHONWARNINGS=error,ignore::SyntaxWarning ). Note that applying such a filter at runtime using the warnings module will only suppress the warning in code that is compiled after the filter is adjusted. Code that is compiled prior to the filter adjustment (for example, when a module is imported) will still emit the syntax warning. (Contributed by Irit Katriel in gh-130080 .) Incremental garbage collection ¶ The cycle garbage collector is now incremental. This means that maximum pause times are reduced by an order of magnitude or more for larger heaps. There are now only two generations: young and old. When gc.collect() is not called directly, the GC is invoked a little less frequently. When invoked, it collects the young generation and an increment of the old generation, instead of collecting one or more generations. The behavior of gc.collect() changes slightly: gc.collect(1) : Performs an increment of garbage collection, rather than collecting generation 1. Other calls to gc.collect() are unchanged. (Contributed by Mark Shannon in gh-108362 .) Default interactive shell ¶ The default interactive shell now highlights Python syntax. The feature is enabled by default, save if PYTHON_BASIC_REPL or any other environment variable that disables colour is set. See Controlling color for details. The default color theme for syntax highlighting strives for good contrast and exclusively uses the 4-bit VGA standard ANSI color codes for maximum compatibility. The theme can be customized using an experimental API _colorize.set_theme() . This can be called interactively or in the PYTHONSTARTUP script. Note that this function has no stability guarantees, and may change or be removed. (Contributed by Łukasz Langa in gh-131507 .) The default interactive shell now supports import auto-completion. This means that typing import co and pressing <Tab> will suggest modules starting with co . Similarly, typing from concurrent import i will suggest submodules of concurrent starting with i . Note that autocompletion of module attributes is not currently supported. (Contributed by Tomas Roun in gh-69605 .) New modules ¶ annotationlib : For introspecting annotations . See PEP 749 for more details. (Contributed by Jelle Zijlstra in gh-119180 .) compression (including compression.zstd ): A package for compression-related modules, including a new module to support the Zstandard compression format. See PEP 784 for more details. (Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in gh-132983 .) concurrent.interpreters : Support for multiple interpreters in the standard library. See PEP 734 for more details. (Contributed by Eric Snow in gh-134939 .) string.templatelib : Support for template string literals (t-strings). See PEP 750 for more details. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in gh-132661 .) Improved modules ¶ argparse ¶ The default value of the program name for argparse.ArgumentParser now reflects the way the Python interpreter was instructed to find the __main__ module code. (Contributed by Serhiy Storchaka and Alyssa Coghlan in gh-66436 .) Introduced the optional suggest_on_error parameter to argparse.ArgumentParser , enabling suggestions for argument choices and subparser names if mistyped by the user. (Contributed by Savannah Ostrowski in gh-124456 .) Enable color for help text, which can be disabled with the optional color parameter to argparse.ArgumentParser . This can also be controlled by environment variables . (Contributed by Hugo van Kemenade in gh-130645 .) ast ¶ Add compare() , a function for comparing two ASTs. (Contributed by Batuhan Taskaya and Jeremy Hylton in gh-60191 .) Add support for copy.replace() for AST nodes. (Contributed by Bénédikt Tran in gh-121141 .) Docstrings are now removed from an optimized AST in optimization level 2. (Contributed by Irit Katriel in gh-123958 .) The repr() output for AST nodes now includes more information. (Contributed by Tomas Roun in gh-116022 .) When called with an AST as input, the parse() function now always verifies that the root node type is appropriate. (Contributed by Irit Katriel in gh-130139 .) Add new options to the command-line interface: --feature-version , --optimize , and --show-empty . (Contributed by Semyon Moroz in gh-133367 .) asyncio ¶ The function and methods named create_task() now take an arbitrary list of keyword arguments. All keyword arguments are passed to the Task constructor or the custom task factory. (See set_task_factory() for details.) The name and context keyword arguments are no longer special; the name should now be set using the name keyword argument of the factory, and context may be None . This affects the following function and methods: asyncio.create_task() , asyncio.loop.create_task() , asyncio.TaskGroup.create_task() . (Contributed by Thomas Grainger in gh-128307 .) There are two new utility functions for introspecting and printing a program’s call graph: capture_call_graph() and print_call_graph() . See Asyncio introspection capabilities for more details. (Contributed by Yury Selivanov, Pablo Galindo Salgado, and Łukasz Langa in gh-91048 .) calendar ¶ By default, today’s date is highlighted in color in calendar ’s command-line text output. This can be controlled by environment variables . (Contributed by Hugo van Kemenade in gh-128317 .) concurrent.futures ¶ Add a new executor class, InterpreterPoolExecutor , which exposes multiple Python interpreters in the same process (‘subinterpreters’) to Python code. This uses a pool of independent Python interpreters to execute calls asynchronously. This is separate from the new interpreters module introduced by PEP 734 . (Contributed by Eric Snow in gh-124548 .) On Unix platforms other than macOS, ‘forkserver’ is now the default start method for ProcessPoolExecutor (replacing ‘fork’ ). This change does not affect Windows or macOS, where ‘spawn’ remains the default start method. If the threading incompatible fork method is required, you must explicitly request it by supplying a multiprocessing context mp_context to ProcessPoolExecutor . See forkserver restrictions for information and differences with the fork method and how this change may affect existing code with mutable global shared variables and/or shared objects that can not be automatically pickled . (Contributed by Gregory P. Smith in gh-84559 .) Add two new methods to ProcessPoolExecutor , terminate_workers() and kill_workers() , as ways to terminate or kill all living worker processes in the given pool. (Contributed by Charles Machalow in gh-130849 .) Add the optional buffersize parameter to Executor.map to limit the number of submitted tasks whose results have not yet been yielded. If the buffer is full, iteration over the iterables pauses until a result is yielded from the buffer. (Contributed by Enzo Bonnal and Josh Rosenberg in gh-74028 .) configparser ¶ configparser will no longer write config files it cannot read, to improve security. Attempting to write() keys containing delimiters or beginning with the section header pattern will raise an InvalidWriteError . (Contributed by Jacob Lincoln in gh-129270 .) contextvars ¶ Support the context manager protocol for Token objects. (Contributed by Andrew Svetlov in gh-129889 .) ctypes ¶ The layout of bit fields in Structure and Union objects is now a closer match to platform defaults (GCC/Clang or MSVC). In particular, fields no longer overlap. (Contributed by Matthias Görgens in gh-97702 .) The Structure._layout_ class attribute can now be set to help match a non-default ABI. (Contributed by Petr Viktorin in gh-97702 .) The class of Structure / Union field descriptors is now available as CField , and has new attributes to aid debugging and introspection. (Contributed by Petr Viktorin in gh-128715 .) On Windows, the COMError exception is now public. (Contributed by Jun Komoda in gh-126686 .) On Windows, the CopyComPointer() function is now public. (Contributed by Jun Komoda in gh-127275 .) Add memoryview_at() , a function to create a memoryview object that refers to the supplied pointer and length. This works like ctypes.string_at() except it avoids a buffer copy, and is typically useful when implementing pure Python callback functions that are passed dynamically-sized buffers. (Contributed by Rian Hunter in gh-112018 .) Complex types, c_float_complex , c_double_complex , and c_longdouble_complex , are now available if both the compiler and the libffi library support complex C types. (Contributed by Sergey B Kirpichev in gh-61103 .) Add ctypes.util.dllist() for listing the shared libraries loaded by the current process. (Contributed by Brian Ward in gh-119349 .) Move ctypes.POINTER() types cache from a global internal cache ( _pointer_type_cache ) to the _CData.__pointer_type__ attribute of the corresponding ctypes types. This will stop the cache from growing without limits in some situations. (Contributed by Sergey Miryanov in gh-100926 .) The py_object type now supports subscription, making it a generic type . (Contributed by Brian Schubert in gh-132168 .) ctypes now supports free-threading builds . (Contributed by Kumar Aditya and Peter Bierma in gh-127945 .) curses ¶ Add the assume_default_colors() function, a refinement of the use_default_colors() function which allows changing the color pair 0 . (Contributed by Serhiy Storchaka in gh-133139 .) datetime ¶ Add the strptime() method to the datetime.date and datetime.time classes. (Contributed by Wannes Boeykens in gh-41431 .) decimal ¶ Add Decimal.from_number() as an alternative constructor for Decimal . (Contributed by Serhiy Storchaka in gh-121798 .) Expose IEEEContext() to support creation of contexts corresponding to the IEEE 754 (2008) decimal interchange formats. (Contributed by Sergey B Kirpichev in gh-53032 .) difflib ¶ Comparison pages with highlighted changes generated by the HtmlDiff class now support ‘dark mode’. (Contributed by Jiahao Li in gh-129939 .) dis ¶ Add support for rendering full source location information of instructions , rather than only the line number. This feature is added to the following interfaces via the show_positions keyword argument: dis.Bytecode dis.dis() dis.distb() dis.disassemble() This feature is also exposed via dis --show-positions . (Contributed by Bénédikt Tran in gh-123165 .) Add the dis --specialized command-line option to show specialized bytecode. (Contributed by Bénédikt Tran in gh-127413 .) errno ¶ Add the EHWPOISON error code constant. (Contributed by James Roy in gh-126585 .) faulthandler ¶ Add support for printing the C stack trace on systems that support it via the new dump_c_stack() function or via the c_stack argument in faulthandler.enable() . (Contributed by Peter Bierma in gh-127604 .) fnmatch ¶ Add filterfalse() , a function to reject names matching a given pattern. (Contributed by Bénédikt Tran in gh-74598 .) fractions ¶ A Fraction object may now be constructed from any object with the as_integer_ratio() method. (Contributed by Serhiy Storchaka in gh-82017 .) Add Fraction.from_number() as an alternative constructor for Fraction . (Contributed by Serhiy Storchaka in gh-121797 .) functools ¶ Add the Placeholder sentinel. This may be used with the partial() or partialmethod() functions to reserve a place for positional arguments in the returned partial object . (Contributed by Dominykas Grigonis in gh-119127 .) Allow the initial parameter of reduce() to be passed as a keyword argument. (Contributed by Sayandip Dutta in gh-125916 .) getopt ¶ Add support for options with optional arguments. (Contributed by Serhiy Storchaka in gh-126374 .) Add support for returning intermixed options and non-option arguments in order. (Contributed by Serhiy Storchaka in gh-126390 .) getpass ¶ Support keyboard feedback in the getpass() function via the keyword-only optional argument echo_char . Placeholder characters are rendered whenever a character is entered, and removed when a character is deleted. (Contributed by Semyon Moroz in gh-77065 .) graphlib ¶ Allow TopologicalSorter.prepare() to be called more than once as long as sorting has not started. (Contributed by Daniel Pope in gh-130914 .) heapq ¶ The heapq module has improved support for working with max-heaps, via the following new functions: heapify_max() heappush_max() heappop_max() heapreplace_max() heappushpop_max() hmac ¶ Add a built-in implementation for HMAC ( RFC 2104 ) using formally verified code from the HACL* project. This implementation is used as a fallback when the OpenSSL implementation of HMAC is not available. (Contributed by Bénédikt Tran in gh-99108 .) http ¶ Directory lists and error pages generated by the http.server module allow the browser to apply its default dark mode. (Contributed by Yorik Hansen in gh-123430 .) The http.server module now supports serving over HTTPS using the http.server.HTTPSServer class. This functionality is exposed by the command-line interface ( python -m http.server ) through the following options: --tls-cert <path> : Path to the TLS certificate file. --tls-key <path> : Optional path to the private key file. --tls-password-file <path> : Optional path to the password file for the private key. (Contributed by Semyon Moroz in gh-85162 .) imaplib ¶ Add IMAP4.idle() , implementing the IMAP4 IDLE command as defined in RFC 2177 . (Contributed by Forest in gh-55454 .) inspect ¶ signature() takes a new argument annotation_format to control the annotationlib.Format used for representing annotations. (Contributed by Jelle Zijlstra in gh-101552 .) Signature.format() takes a new argument unquote_annotations . If true, string annotations are displayed without surrounding quotes. (Contributed by Jelle Zijlstra in gh-101552 .) Add function ispackage() to determine whether an object is a package or not. (Contributed by Zhikang Yan in gh-125634 .) io ¶ Reading text from a non-blocking stream with read may now raise a BlockingIOError if the operation cannot immediately return bytes. (Contributed by Giovanni Siragusa in gh-109523 .) Add the Reader and Writer protocols as simpler alternatives to the pseudo-protocols typing.IO , typing.TextIO , and typing.BinaryIO . (Contributed by Sebastian Rittau in gh-127648 .) json ¶ Add exception notes for JSON serialization errors that allow identifying the source of the error. (Contributed by Serhiy Storchaka in gh-122163 .) Allow using the json module as a script using the -m switch: python -m json . This is now preferred to python -m json.tool , which is soft deprecated . See the JSON command-line interface documentation. (Contributed by Trey Hunner in gh-122873 .) By default, the output of the JSON command-line interface is highlighted in color. This can be controlled by environment variables . (Contributed by Tomas Roun in gh-131952 .) linecache ¶ getline() can now retrieve source code for frozen modules. (Contributed by Tian Gao in gh-131638 .) logging.handlers ¶ QueueListener objects now support the context manager protocol. (Contributed by Charles Machalow in gh-132106 .) QueueListener.start now raises a RuntimeError if the listener is already started. (Contributed by Charles Machalow in gh-132106 .) math ¶ Added more detailed error messages for domain errors in the module. (Contributed by Charlie Zhao and Sergey B Kirpichev in gh-101410 .) mimetypes ¶ Add a public command-line for the module, invoked via python -m mimetypes . (Contributed by Oleg Iarygin and Hugo van Kemenade in gh-93096 .) Add several new MIME types based on RFCs and common usage: Microsoft and RFC 8081 MIME types for fonts Embedded OpenType: application/vnd.ms-fontobject OpenType Layout (OTF) font/otf TrueType: font/ttf WOFF 1.0 font/woff WOFF 2.0 font/woff2 RFC 9559	2026-01-13T08:49:46
https://docs.python.org/3.15/whatsnew/3.15.html#improved-error-messages	What’s new in Python 3.15 — Python 3.15.0a3 documentation Theme Auto Light Dark Table of Contents What’s new in Python 3.15 Summary – Release highlights New features PEP 799 : A dedicated profiling package Tachyon: High frequency statistical sampling profiler Improved error messages Other language changes New modules math.integer Improved modules argparse base64 & binascii calendar collections collections.abc concurrent.futures dataclasses dbm difflib functools hashlib http.client http.cookies inspect locale math mimetypes mmap os os.path resource shelve socket sqlite3 ssl sys tarfile timeit tkinter types unicodedata unittest venv warnings xml.parsers.expat zlib Optimizations csv Upgraded JIT compiler Removed ctypes glob http.server importlib.resources pathlib platform sre_* sysconfig threading typing wave zipimport Deprecated New deprecations Pending removal in Python 3.16 Pending removal in Python 3.17 Pending removal in Python 3.18 Pending removal in Python 3.19 Pending removal in Python 3.20 Pending removal in future versions C API changes New features Changed C APIs Porting to Python 3.15 Removed C APIs Deprecated C APIs Build changes Porting to Python 3.15 Previous topic What’s New in Python Next topic What’s new in Python 3.14 This page Report a bug Show source Navigation index modules \| next \| previous \| Python » 3.15.0a3 Documentation » What’s New in Python » What’s new in Python 3.15 \| Theme Auto Light Dark \| What’s new in Python 3.15 ¶ Editor : Hugo van Kemenade This article explains the new features in Python 3.15, compared to 3.14. For full details, see the changelog . Note Prerelease users should be aware that this document is currently in draft form. It will be updated substantially as Python 3.15 moves towards release, so it’s worth checking back even after reading earlier versions. Summary – Release highlights ¶ PEP 799 : A dedicated profiling package for organizing Python profiling tools PEP 799 : Tachyon: High frequency statistical sampling profiler profiling tools PEP 686 : Python now uses UTF-8 as the default encoding PEP 782 : A new PyBytesWriter C API to create a Python bytes object The JIT compiler has been significantly upgraded Improved error messages New features ¶ PEP 799 : A dedicated profiling package ¶ A new profiling module has been added to organize Python’s built-in profiling tools under a single, coherent namespace. This module contains: profiling.tracing : deterministic function-call tracing (relocated from cProfile ). profiling.sampling : a new statistical sampling profiler (named Tachyon). The cProfile module remains as an alias for backwards compatibility. The profile module is deprecated and will be removed in Python 3.17. See also PEP 799 for further details. (Contributed by Pablo Galindo and László Kiss Kollár in gh-138122 .) Tachyon: High frequency statistical sampling profiler ¶ A new statistical sampling profiler (Tachyon) has been added as profiling.sampling . This profiler enables low-overhead performance analysis of running Python processes without requiring code modification or process restart. Unlike deterministic profilers (such as profiling.tracing ) that instrument every function call, the sampling profiler periodically captures stack traces from running processes. This approach provides virtually zero overhead while achieving sampling rates of up to 1,000,000 Hz , making it the fastest sampling profiler available for Python (at the time of its contribution) and ideal for debugging performance issues in production environments. This capability is particularly valuable for debugging performance issues in production systems where traditional profiling approaches would be too intrusive. Key features include: Zero-overhead profiling : Attach to any running Python process without affecting its performance. Ideal for production debugging where you can’t afford to restart or slow down your application. No code modification required : Profile existing applications without restart. Simply point the profiler at a running process by PID and start collecting data. Flexible target modes : Profile running processes by PID ( attach ) - attach to already-running applications Run and profile scripts directly ( run ) - profile from the very start of execution Execute and profile modules ( run -m ) - profile packages run as python -m module Multiple profiling modes : Choose what to measure based on your performance investigation: Wall-clock time ( --mode wall , default): Measures real elapsed time including I/O, network waits, and blocking operations. Use this to understand where your program spends calendar time, including when waiting for external resources. CPU time ( --mode cpu ): Measures only active CPU execution time, excluding I/O waits and blocking. Use this to identify CPU-bound bottlenecks and optimize computational work. GIL-holding time ( --mode gil ): Measures time spent holding Python’s Global Interpreter Lock. Use this to identify which threads dominate GIL usage in multi-threaded applications. Exception handling time ( --mode exception ): Captures samples only from threads with an active exception. Use this to analyze exception handling overhead. Thread-aware profiling : Option to profile all threads ( -a ) or just the main thread, essential for understanding multi-threaded application behavior. Multiple output formats : Choose the visualization that best fits your workflow: --pstats : Detailed tabular statistics compatible with pstats . Shows function-level timing with direct and cumulative samples. Best for detailed analysis and integration with existing Python profiling tools. --collapsed : Generates collapsed stack traces (one line per stack). This format is specifically designed for creating flamegraphs with external tools like Brendan Gregg’s FlameGraph scripts or speedscope. --flamegraph : Generates a self-contained interactive HTML flamegraph using D3.js. Opens directly in your browser for immediate visual analysis. Flamegraphs show the call hierarchy where width represents time spent, making it easy to spot bottlenecks at a glance. --gecko : Generates Gecko Profiler format compatible with Firefox Profiler ( https://profiler.firefox.com ). Upload the output to Firefox Profiler for advanced timeline-based analysis with features like stack charts, markers, and network activity. --heatmap : Generates an interactive HTML heatmap visualization with line-level sample counts. Creates a directory with per-file heatmaps showing exactly where time is spent at the source code level. Live interactive mode : Real-time TUI profiler with a top-like interface ( --live ). Monitor performance as your application runs with interactive sorting and filtering. Async-aware profiling : Profile async/await code with task-based stack reconstruction ( --async-aware ). See which coroutines are consuming time, with options to show only running tasks or all tasks including those waiting. Opcode-level profiling : Gather bytecode opcode information for instruction-level profiling ( --opcodes ). Shows which bytecode instructions are executing, including specializations from the adaptive interpreter. See profiling.sampling for the complete documentation, including all available output formats, profiling modes, and configuration options. (Contributed by Pablo Galindo and László Kiss Kollár in gh-135953 and gh-138122 .) Improved error messages ¶ The interpreter now provides more helpful suggestions in AttributeError exceptions when accessing an attribute on an object that does not exist, but a similar attribute is available through one of its members. For example, if the object has an attribute that itself exposes the requested name, the error message will suggest accessing it via that inner attribute: @dataclass class Circle : radius : float @property def area ( self ) -> float : return pi * self . radius ** 2 class Container : def __init__ ( self , inner : Circle ) -> None : self . inner = inner circle = Circle ( radius = 4.0 ) container = Container ( circle ) print ( container . area ) Running this code now produces a clearer suggestion: Traceback (most recent call last): File "/home/pablogsal/github/python/main/lel.py", line 42, in <module> print(container.area) ^^^^^^^^^^^^^^ AttributeError : 'Container' object has no attribute 'area'. Did you mean: 'inner.area'? Other language changes ¶ Python now uses UTF-8 as the default encoding, independent of the system’s environment. This means that I/O operations without an explicit encoding, for example, open('flying-circus.txt') , will use UTF-8. UTF-8 is a widely-supported Unicode character encoding that has become a de facto standard for representing text, including nearly every webpage on the internet, many common file formats, programming languages, and more. This only applies when no encoding argument is given. For best compatibility between versions of Python, ensure that an explicit encoding argument is always provided. The opt-in encoding warning can be used to identify code that may be affected by this change. The special encoding='locale' argument uses the current locale encoding, and has been supported since Python 3.10. To retain the previous behaviour, Python’s UTF-8 mode may be disabled with the PYTHONUTF8=0 environment variable or the -X utf8=0 command-line option. See also PEP 686 for further details. (Contributed by Adam Turner in gh-133711 ; PEP 686 written by Inada Naoki.) Several error messages incorrectly using the term “argument” have been corrected. (Contributed by Stan Ulbrych in gh-133382 .) The interpreter now tries to provide a suggestion when delattr() fails due to a missing attribute. When an attribute name that closely resembles an existing attribute is used, the interpreter will suggest the correct attribute name in the error message. For example: >>> class A : ... pass >>> a = A () >>> a . abcde = 1 >>> del a . abcdf Traceback (most recent call last): ... AttributeError : 'A' object has no attribute 'abcdf'. Did you mean: 'abcde'? (Contributed by Nikita Sobolev and Pranjal Prajapati in gh-136588 .) Unraisable exceptions are now highlighted with color by default. This can be controlled by environment variables . (Contributed by Peter Bierma in gh-134170 .) The __repr__() of ImportError and ModuleNotFoundError now shows “name” and “path” as name=<name> and path=<path> if they were given as keyword arguments at construction time. (Contributed by Serhiy Storchaka, Oleg Iarygin, and Yoav Nir in gh-74185 .) The __dict__ and __weakref__ descriptors now use a single descriptor instance per interpreter, shared across all types that need them. This speeds up class creation, and helps avoid reference cycles. (Contributed by Petr Viktorin in gh-135228 .) The -W option and the PYTHONWARNINGS environment variable can now specify regular expressions instead of literal strings to match the warning message and the module name, if the corresponding field starts and ends with a forward slash ( / ). (Contributed by Serhiy Storchaka in gh-134716 .) Functions that take timestamp or timeout arguments now accept any real numbers (such as Decimal and Fraction ), not only integers or floats, although this does not improve precision. (Contributed by Serhiy Storchaka in gh-67795 .) Added bytearray.take_bytes(n=None, /) to take bytes out of a bytearray without copying. This enables optimizing code which must return bytes after working with a mutable buffer of bytes such as data buffering, network protocol parsing, encoding, decoding, and compression. Common code patterns which can be optimized with take_bytes() are listed below. Suggested optimizing refactors ¶ Description Old New Return bytes after working with bytearray def read () -> bytes : buffer = bytearray ( 1024 ) ... return bytes ( buffer ) def read () -> bytes : buffer = bytearray ( 1024 ) ... return buffer . take_bytes () Empty a buffer getting the bytes buffer = bytearray ( 1024 ) ... data = bytes ( buffer ) buffer . clear () buffer = bytearray ( 1024 ) ... data = buffer . take_bytes () Split a buffer at a specific separator buffer = bytearray ( b 'abc \n def' ) n = buffer . find ( b ' \n ' ) data = bytes ( buffer [: n + 1 ]) del buffer [: n + 1 ] assert data == b 'abc' assert buffer == bytearray ( b 'def' ) buffer = bytearray ( b 'abc \n def' ) n = buffer . find ( b ' \n ' ) data = buffer . take_bytes ( n + 1 ) Split a buffer at a specific separator; discard after the separator buffer = bytearray ( b 'abc \n def' ) n = buffer . find ( b ' \n ' ) data = bytes ( buffer [: n ]) buffer . clear () assert data == b 'abc' assert len ( buffer ) == 0 buffer = bytearray ( b 'abc \n def' ) n = buffer . find ( b ' \n ' ) buffer . resize ( n ) data = buffer . take_bytes () (Contributed by Cody Maloney in gh-139871 .) Many functions related to compiling or parsing Python code, such as compile() , ast.parse() , symtable.symtable() , and importlib.abc.InspectLoader.source_to_code() , now allow the module name to be passed. It is needed to unambiguously filter syntax warnings by module name. (Contributed by Serhiy Storchaka in gh-135801 .) Allowed defining the __dict__ and __weakref__ __slots__ for any class. (Contributed by Serhiy Storchaka in gh-41779 .) Allowed defining any __slots__ for a class derived from tuple (including classes created by collections.namedtuple() ). (Contributed by Serhiy Storchaka in gh-41779 .) The slice type now supports subscription, making it a generic type . (Contributed by James Hilton-Balfe in gh-128335 .) New modules ¶ math.integer ¶ This module provides access to the mathematical functions for integer arguments ( PEP 791 ). (Contributed by Serhiy Storchaka in gh-81313 .) Improved modules ¶ argparse ¶ The BooleanOptionalAction action supports now single-dash long options and alternate prefix characters. (Contributed by Serhiy Storchaka in gh-138525 .) Changed the suggest_on_error parameter of argparse.ArgumentParser to default to True . This enables suggestions for mistyped arguments by default. (Contributed by Jakob Schluse in gh-140450 .) Added backtick markup support in description and epilog text to highlight inline code when color output is enabled. (Contributed by Savannah Ostrowski in gh-142390 .) base64 & binascii ¶ CPython’s underlying base64 implementation now encodes 2x faster and decodes 3x faster thanks to simple CPU pipelining optimizations. (Contributed by Gregory P. Smith & Serhiy Storchaka in gh-143262 .) calendar ¶ Calendar pages generated by the calendar.HTMLCalendar class now support dark mode and have been migrated to the HTML5 standard for improved accessibility. (Contributed by Jiahao Li and Hugo van Kemenade in gh-137634 .) The calendar ’s command-line HTML output now accepts the year-month option: python -m calendar -t html 2009 06 . (Contributed by Pål Grønås Drange in gh-140212 .) collections ¶ Added collections.Counter.__xor__() and collections.Counter.__ixor__() to compute the symmetric difference between Counter objects. (Contributed by Raymond Hettinger in gh-138682 .) collections.abc ¶ collections.abc.ByteString has been removed from collections.abc.__all__ . collections.abc.ByteString has been deprecated since Python 3.12, and is scheduled for removal in Python 3.17. The following statements now cause DeprecationWarning s to be emitted at runtime: from collections.abc import ByteString import collections.abc; collections.abc.ByteString . DeprecationWarning s were already emitted if collections.abc.ByteString was subclassed or used as the second argument to isinstance() or issubclass() , but warnings were not previously emitted if it was merely imported or accessed from the collections.abc module. concurrent.futures ¶ Improved error reporting when a child process in a concurrent.futures.ProcessPoolExecutor terminates abruptly. The resulting traceback will now tell you the PID and exit code of the terminated process. (Contributed by Jonathan Berg in gh-139486 .) dataclasses ¶ Annotations for generated __init__ methods no longer include internal type names. dbm ¶ Added new reorganize() methods to dbm.dumb and dbm.sqlite3 which allow to recover unused free space previously occupied by deleted entries. (Contributed by Andrea Oliveri in gh-134004 .) difflib ¶ Introduced the optional color parameter to difflib.unified_diff() , enabling color output similar to git diff . This can be controlled by environment variables . (Contributed by Douglas Thor in gh-133725 .) Improved the styling of HTML diff pages generated by the difflib.HtmlDiff class, and migrated the output to the HTML5 standard. (Contributed by Jiahao Li in gh-134580 .) functools ¶ singledispatchmethod() now supports non- descriptor callables. (Contributed by Serhiy Storchaka in gh-140873 .) hashlib ¶ Ensure that hash functions guaranteed to be always available exist as attributes of hashlib even if they will not work at runtime due to missing backend implementations. For instance, hashlib.md5 will no longer raise AttributeError if OpenSSL is not available and Python has been built without MD5 support. (Contributed by Bénédikt Tran in gh-136929 .) http.client ¶ A new max_response_headers keyword-only parameter has been added to HTTPConnection and HTTPSConnection constructors. This parameter overrides the default maximum number of allowed response headers. (Contributed by Alexander Enrique Urieles Nieto in gh-131724 .) http.cookies ¶ Allow ‘ " ’ double quotes in cookie values. (Contributed by Nick Burns and Senthil Kumaran in gh-92936 .) inspect ¶ Add parameters inherit_class_doc and fallback_to_class_doc for getdoc() . (Contributed by Serhiy Storchaka in gh-132686 .) locale ¶ setlocale() now supports language codes with @ -modifiers. @ -modifiers are no longer silently removed in getlocale() , but included in the language code. (Contributed by Serhiy Storchaka in gh-137729 .) Undeprecate the locale.getdefaultlocale() function. (Contributed by Victor Stinner in gh-130796 .) math ¶ Add math.isnormal() and math.issubnormal() functions. (Contributed by Sergey B Kirpichev in gh-132908 .) Add math.fmax() , math.fmin() and math.signbit() functions. (Contributed by Bénédikt Tran in gh-135853 .) mimetypes ¶ Add application/node MIME type for .cjs extension. (Contributed by John Franey in gh-140937 .) Add application/toml . (Contributed by Gil Forcada in gh-139959 .) Rename application/x-texinfo to application/texinfo . (Contributed by Charlie Lin in gh-140165 .) Changed the MIME type for .ai files to application/pdf . (Contributed by Stan Ulbrych in gh-141239 .) mmap ¶ mmap.mmap now has a trackfd parameter on Windows; if it is False , the file handle corresponding to fileno will not be duplicated. (Contributed by Serhiy Storchaka in gh-78502 .) Added the mmap.mmap.set_name() method to annotate an anonymous memory mapping if Linux kernel supports PR_SET_VMA_ANON_NAME (Linux 5.17 or newer). (Contributed by Donghee Na in gh-142419 .) os ¶ Add os.statx() on Linux kernel versions 4.11 and later with glibc versions 2.28 and later. (Contributed by Jeffrey Bosboom and Victor Stinner in gh-83714 .) os.path ¶ Add support of the all-but-last mode in realpath() . (Contributed by Serhiy Storchaka in gh-71189 .) The strict parameter to os.path.realpath() accepts a new value, os.path.ALLOW_MISSING . If used, errors other than FileNotFoundError will be re-raised; the resulting path can be missing but it will be free of symlinks. (Contributed by Petr Viktorin for CVE 2025-4517 .) resource ¶ Add new constants: RLIMIT_NTHR , RLIMIT_UMTXP , RLIMIT_THREADS , RLIM_SAVED_CUR , and RLIM_SAVED_MAX . (Contributed by Serhiy Storchaka in gh-137512 .) shelve ¶ Added new reorganize() method to shelve used to recover unused free space previously occupied by deleted entries. (Contributed by Andrea Oliveri in gh-134004 .) socket ¶ Add constants for the ISO-TP CAN protocol. (Contributed by Patrick Menschel and Stefan Tatschner in gh-86819 .) sqlite3 ¶ The command-line interface has several new features: SQL keyword completion on <tab>. (Contributed by Long Tan in gh-133393 .) Prompts, error messages, and help text are now colored. This is enabled by default, see Controlling color for details. (Contributed by Stan Ulbrych and Łukasz Langa in gh-133461 .) Table, index, trigger, view, column, function, and schema completion on <tab>. (Contributed by Long Tan in gh-136101 .) ssl ¶ Indicate through ssl.HAS_PSK_TLS13 whether the ssl module supports “External PSKs” in TLSv1.3, as described in RFC 9258. (Contributed by Will Childs-Klein in gh-133624 .) Added new methods for managing groups used for SSL key agreement ssl.SSLContext.set_groups() sets the groups allowed for doing key agreement, extending the previous ssl.SSLContext.set_ecdh_curve() method. This new API provides the ability to list multiple groups and supports fixed-field and post-quantum groups in addition to ECDH curves. This method can also be used to control what key shares are sent in the TLS handshake. ssl.SSLSocket.group() returns the group selected for doing key agreement on the current connection after the TLS handshake completes. This call requires OpenSSL 3.2 or later. ssl.SSLContext.get_groups() returns a list of all available key agreement groups compatible with the minimum and maximum TLS versions currently set in the context. This call requires OpenSSL 3.5 or later. (Contributed by Ron Frederick in gh-136306 .) Added a new method ssl.SSLContext.set_ciphersuites() for setting TLS 1.3 ciphers. For TLS 1.2 or earlier, ssl.SSLContext.set_ciphers() should continue to be used. Both calls can be made on the same context and the selected cipher suite will depend on the TLS version negotiated when a connection is made. (Contributed by Ron Frederick in gh-137197 .) Added new methods for managing signature algorithms: ssl.get_sigalgs() returns a list of all available TLS signature algorithms. This call requires OpenSSL 3.4 or later. ssl.SSLContext.set_client_sigalgs() sets the signature algorithms allowed for certificate-based client authentication. ssl.SSLContext.set_server_sigalgs() sets the signature algorithms allowed for the server to complete the TLS handshake. ssl.SSLSocket.client_sigalg() returns the signature algorithm selected for client authentication on the current connection. This call requires OpenSSL 3.5 or later. ssl.SSLSocket.server_sigalg() returns the signature algorithm selected for the server to complete the TLS handshake on the current connection. This call requires OpenSSL 3.5 or later. (Contributed by Ron Frederick in gh-138252 .) sys ¶ Add sys.abi_info namespace to improve access to ABI information. (Contributed by Klaus Zimmermann in gh-137476 .) tarfile ¶ data_filter() now normalizes symbolic link targets in order to avoid path traversal attacks. (Contributed by Petr Viktorin in gh-127987 and CVE 2025-4138 .) extractall() now skips fixing up directory attributes when a directory was removed or replaced by another kind of file. (Contributed by Petr Viktorin in gh-127987 and CVE 2024-12718 .) extract() and extractall() now (re-)apply the extraction filter when substituting a link (hard or symbolic) with a copy of another archive member, and when fixing up directory attributes. The former raises a new exception, LinkFallbackError . (Contributed by Petr Viktorin for CVE 2025-4330 and CVE 2024-12718 .) extract() and extractall() no longer extract rejected members when errorlevel() is zero. (Contributed by Matt Prodani and Petr Viktorin in gh-112887 and CVE 2025-4435 .) extract() and extractall() now replace slashes by backslashes in symlink targets on Windows to prevent creation of corrupted links. (Contributed by Christoph Walcher in gh-57911 .) timeit ¶ The command-line interface now colorizes error tracebacks by default. This can be controlled with environment variables . (Contributed by Yi Hong in gh-139374 .) tkinter ¶ The tkinter.Text.search() method now supports two additional arguments: nolinestop which allows the search to continue across line boundaries; and strictlimits which restricts the search to within the specified range. (Contributed by Rihaan Meher in gh-130848 ) A new method tkinter.Text.search_all() has been introduced. This method allows for searching for all matches of a pattern using Tcl’s -all and -overlap options. (Contributed by Rihaan Meher in gh-130848 ) types ¶ Expose the write-through locals() proxy type as types.FrameLocalsProxyType . This represents the type of the frame.f_locals attribute, as described in PEP 667 . unicodedata ¶ The Unicode database has been updated to Unicode 17.0.0. Add unicodedata.isxidstart() and unicodedata.isxidcontinue() functions to check whether a character can start or continue a Unicode Standard Annex #31 identifier. (Contributed by Stan Ulbrych in gh-129117 .) unittest ¶ unittest.TestCase.assertLogs() will now accept a formatter to control how messages are formatted. (Contributed by Garry Cairns in gh-134567 .) venv ¶ On POSIX platforms, platlib directories will be created if needed when creating virtual environments, instead of using lib64 -> lib symlink. This means purelib and platlib of virtual environments no longer share the same lib directory on platforms where sys.platlibdir is not equal to lib . (Contributed by Rui Xi in gh-133951 .) warnings ¶ Improve filtering by module in warnings.warn_explicit() if no module argument is passed. It now tests the module regular expression in the warnings filter not only against the filename with .py stripped, but also against module names constructed starting from different parent directories of the filename (with /__init__.py , .py and, on Windows, .pyw stripped). (Contributed by Serhiy Storchaka in gh-135801 .) xml.parsers.expat ¶ Add SetAllocTrackerActivationThreshold() and SetAllocTrackerMaximumAmplification() to xmlparser objects to tune protections against disproportional amounts of dynamic memory usage from within an Expat parser. (Contributed by Bénédikt Tran in gh-90949 .) Add SetBillionLaughsAttackProtectionActivationThreshold() and SetBillionLaughsAttackProtectionMaximumAmplification() to xmlparser objects to tune protections against billion laughs attacks. (Contributed by Bénédikt Tran in gh-90949 .) zlib ¶ Allow combining two Adler-32 checksums via adler32_combine() . (Contributed by Callum Attryde and Bénédikt Tran in gh-134635 .) Allow combining two CRC-32 checksums via crc32_combine() . (Contributed by Bénédikt Tran in gh-134635 .) Optimizations ¶ Builds using Visual Studio 2026 (MSVC 18) may now use the new tail-calling interpreter . Results on Visual Studio 18.1.1 report between 15-20% speedup on the geometric mean of pyperformance on Windows x86-64 over the switch-case interpreter on an AMD Ryzen 7 5800X. We have observed speedups ranging from 14% for large pure-Python libraries to 40% for long-running small pure-Python scripts on Windows. This was made possible by a new feature introduced in MSVC 18. (Contributed by Chris Eibl, Ken Jin, and Brandt Bucher in gh-143068 . Special thanks to the MSVC team including Hulon Jenkins.) csv ¶ csv.Sniffer.sniff() delimiter detection is now up to 1.6x faster. (Contributed by Maurycy Pawłowski-Wieroński in gh-137628 .) Upgraded JIT compiler ¶ Results from the pyperformance benchmark suite report 4-5% geometric mean performance improvement for the JIT over the standard CPython interpreter built with all optimizations enabled on x86-64 Linux. On AArch64 macOS, the JIT has a 7-8% speedup over the tail calling interpreter with all optimizations enabled. The speedups for JIT builds versus no JIT builds range from roughly 15% slowdown to over 100% speedup (ignoring the unpack_sequence microbenchmark) on x86-64 Linux and AArch64 macOS systems. Attention These results are not yet final. The major upgrades to the JIT are: LLVM 21 build-time dependency New tracing frontend Basic register allocation in the JIT More JIT optimizations Better machine code generation LLVM 21 build-time dependency The JIT compiler now uses LLVM 21 for build-time stencil generation. As always, LLVM is only needed when building CPython with the JIT enabled; end users running Python do not need LLVM installed. Instructions for installing LLVM can be found in the JIT compiler documentation for all supported platforms. (Contributed by Savannah Ostrowski in gh-140973 .) A new tracing frontend The JIT compiler now supports significantly more bytecode operations and control flow than in Python 3.14, enabling speedups on a wider variety of code. For example, simple Python object creation is now understood by the 3.15 JIT compiler. Overloaded operations and generators are also partially supported. This was made possible by an overhauled JIT tracing frontend that records actual execution paths through code, rather than estimating them as the previous implementation did. (Contributed by Ken Jin in gh-139109 . Support for Windows added by Mark Shannon in gh-141703 .) Basic register allocation in the JIT A basic form of register allocation has been added to the JIT compiler’s optimizer. This allows the JIT compiler to avoid certain stack operations altogether and instead operate on registers. This allows the JIT to produce more efficient traces by avoiding reads and writes to memory. (Contributed by Mark Shannon in gh-135379 .) More JIT optimizations More constant-propagation is now performed. This means when the JIT compiler detects that certain user code results in constants, the code can be simplified by the JIT. (Contributed by Ken Jin and Savannah Ostrowski in gh-132732 .) The JIT avoids reference count s where possible. This generally reduces the cost of most operations in Python. (Contributed by Ken Jin, Donghee Na, Zheao Li, Hai Zhu, Savannah Ostrowski, Reiden Ong, Noam Cohen, Tomas Roun, PuQing, and Cajetan Rodrigues in gh-134584 .) Better machine code generation The JIT compiler’s machine code generator now produces better machine code for x86-64 and AArch64 macOS and Linux targets. In general, users should experience lower memory usage for generated machine code and more efficient machine code versus the old JIT. (Contributed by Brandt Bucher in gh-136528 and gh-136528 . Implementation for AArch64 contributed by Mark Shannon in gh-139855 . Additional optimizations for AArch64 contributed by Mark Shannon and Diego Russo in gh-140683 and gh-142305 .) Removed ¶ ctypes ¶ Removed the undocumented function ctypes.SetPointerType() , which has been deprecated since Python 3.13. (Contributed by Bénédikt Tran in gh-133866 .) glob ¶ Removed the undocumented glob.glob0() and glob.glob1() functions, which have been deprecated since Python 3.13. Use glob.glob() and pass a directory to its root_dir argument instead. (Contributed by Barney Gale in gh-137466 .) http.server ¶ Removed the CGIHTTPRequestHandler class and the --cgi flag from the python -m http.server command-line interface. They were deprecated in Python 3.13. (Contributed by Bénédikt Tran in gh-133810 .) importlib.resources ¶ Removed deprecated package parameter from importlib.resources.files() function. (Contributed by Semyon Moroz in gh-138044 ) pathlib ¶ Removed deprecated pathlib.PurePath.is_reserved() . Use os.path.isreserved() to detect reserved paths on Windows. (Contributed by Nikita Sobolev in gh-133875 .) platform ¶ Removed the platform.java_ver() function, which was deprecated since Python 3.13. (Contributed by Alexey Makridenko in gh-133604 .) sre_* ¶ Removed sre_compile , sre_constants and sre_parse modules. (Contributed by Stan Ulbrych in gh-135994 .) sysconfig ¶ Removed the check_home parameter of sysconfig.is_python_build() . (Contributed by Filipe Laíns in gh-92897 .) threading ¶ Remove support for arbitrary positional or keyword arguments in the C implementation of RLock objects. This was deprecated in Python 3.14. (Contributed by Bénédikt Tran in gh-134087 .) typing ¶ The undocumented keyword argument syntax for creating NamedTuple classes (for example, Point = NamedTuple("Point", x=int, y=int) ) is no longer supported. Use the class-based syntax or the functional syntax instead. (Contributed by Bénédikt Tran in gh-133817 .) Using TD = TypedDict("TD") or TD = TypedDict("TD", None) to construct a TypedDict type with zero fields is no longer supported. Use class TD(TypedDict): pass or TD = TypedDict("TD", {}) instead. (Contributed by Bénédikt Tran in gh-133823 .) Code like class ExtraTypeVars(P1[S], Protocol[T, T2]): ... now raises a TypeError , because S is not listed in Protocol parameters. (Contributed by Nikita Sobolev in gh-137191 .) Code like class B2(A[T2], Protocol[T1, T2]): ... now correctly handles type parameters order: it is (T1, T2) , not (T2, T1) as it was incorrectly inferred in runtime before. (Contributed by Nikita Sobolev in gh-137191 .) typing.ByteString has been removed from typing.__all__ . typing.ByteString has been deprecated since Python 3.9, and is scheduled for removal in Python 3.17. The following statements now cause DeprecationWarning s to be emitted at runtime: from typing import ByteString import typing; typing.ByteString . DeprecationWarning s were already emitted if typing.ByteString was subclassed or used as the second argument to isinstance() or issubclass() , but warnings were not previously emitted if it was merely imported or accessed from the typing module. Deprecated typing.no_type_check_decorator() has been removed. (Contributed by Nikita Sobolev in gh-133601 .) wave ¶ Removed the getmark() , setmark() and getmarkers() methods of the Wave_read and Wave_write classes, which were deprecated since Python 3.13. (Contributed by Bénédikt Tran in gh-133873 .) zipimport ¶ Remove deprecated zipimport.zipimporter.load_module() . Use zipimport.zipimporter.exec_module() instead. (Contributed by Jiahao Li in gh-133656 .) Deprecated ¶ New deprecations ¶ CLI: Deprecate -b and -bb command-line options and schedule them to become no-ops in Python 3.17. These were primarily helpers for the Python 2 -> 3 transition. Starting with Python 3.17, no BytesWarning will be raised for these cases; use a type checker instead. (Contributed by Nikita Sobolev in gh-136355 .) hashlib : In hash function constructors such as new() or the direct hash-named constructors such as md5() and sha256() , the optional initial data parameter could also be passed as a keyword argument named data= or string= in various hashlib implementations. Support for the string keyword argument name is now deprecated and is slated for removal in Python 3.19. Prefer passing the initial data as a positional argument for maximum backwards compatibility. (Contributed by Bénédikt Tran in gh-134978 .) __version__ The __version__ , version and VERSION attributes have been deprecated in these standard library modules and will be removed in Python 3.20. Use sys.version_info instead. argparse csv ctypes ctypes.macholib decimal (use decimal.SPEC_VERSION instead) http.server imaplib ipaddress json logging ( __date__ also deprecated) optparse pickle platform re socketserver tabnanny tkinter.font tkinter.ttk wsgiref.simple_server xml.etree.ElementTree xml.sax.expatreader xml.sax.handler zlib (Contributed by Hugo van Kemenade and Stan Ulbrych in gh-76007 .) Pending removal in Python 3.16 ¶ The import system: Setting __loader__ on a module while failing to set __spec__.loader is deprecated. In Python 3.16, __loader__ will cease to be set or taken into consideration by the import system or the standard library. array : The 'u' format code ( wchar_t ) has been deprecated in documentation since Python 3.3 and at runtime since Python 3.13. Use the 'w' format code ( Py_UCS4 ) for Unicode characters instead. asyncio : asyncio.iscoroutinefunction() is deprecated and will be removed in Python 3.16; use inspect.iscoroutinefunction() instead. (Contributed by Jiahao Li and Kumar Aditya in gh-122875 .) asyncio policy system is deprecated and will be removed in Python 3.16. In particular, the following classes and functions are deprecated: asyncio.AbstractEventLoopPolicy asyncio.DefaultEventLoopPolicy asyncio.WindowsSelectorEventLoopPolicy asyncio.WindowsProactorEventLoopPolicy asyncio.get_event_loop_policy() asyncio.set_event_loop_policy() Users should use asyncio.run() or asyncio.Runner with loop_factory to use the desired event loop implementation. For example, to use asyncio.SelectorEventLoop on Windows: import asyncio async def main (): ... asyncio . run ( main (), loop_factory = asyncio . SelectorEventLoop ) (Contributed by Kumar Aditya in gh-127949 .) builtins : Bitwise inversion on boolean types, ~True or ~False has been deprecated since Python 3.12, as it produces surprising and unintuitive results ( -2 and -1 ). Use not x instead for the logical negation of a Boolean. In the rare case that you need the bitwise inversion of the underlying integer, convert to int explicitly ( ~int(x) ). functools : Calling the Python implementation of functools.reduce() with function or sequence as keyword arguments has been deprecated since Python 3.14. logging : Support for custom logging handlers with the strm argument is deprecated and scheduled for removal in Python 3.16. Define handlers with the stream argument instead. (Contributed by Mariusz Felisiak in gh-115032 .) mimetypes : Valid extensions start with a ‘.’ or are empty for mimetypes.MimeTypes.add_type() . Undotted extensions are deprecated and will raise a ValueError in Python 3.16. (Contributed by Hugo van Kemenade in gh-75223 .) shutil : The ExecError exception has been deprecated since Python 3.14. It has not been used by any function in shutil since Python 3.4, and is now an alias of RuntimeError . symtable : The Class.get_methods method has been deprecated since Python 3.14. sys : The _enablelegacywindowsfsencoding() function has been deprecated since Python 3.13. Use the PYTHONLEGACYWINDOWSFSENCODING environment variable instead. sysconfig : The sysconfig.expand_makefile_vars() function has been deprecated since Python 3.14. Use the vars argument of sysconfig.get_paths() instead. tarfile : The undocumented and unused TarFile.tarfile attribute has been deprecated since Python 3.13. Pending removal in Python 3.17 ¶ collections.abc : collections.abc.ByteString is scheduled for removal in Python 3.17. Use isinstance(obj, collections.abc.Buffer) to test if obj implements the buffer protocol at runtime. For use in type annotations, either use Buffer or a union that explicitly specifies the types your code supports (e.g., bytes \| bytearray \| memoryview ). ByteString was originally intended to be an abstract class that would serve as a supertype of both bytes and bytearray . However, since the ABC never had any methods, knowing that an object was an instance of ByteString never actually told you anything useful about the object. Other common buffer types such as memoryview were also never understood as subtypes of ByteString (either at runtime or by static type checkers). See PEP 688 for more details. (Contributed by Shantanu Jain in gh-91896 .) encodings : Passing non-ascii encoding names to encodings.normalize_encoding() is deprecated and scheduled for removal in Python 3.17. (Contributed by Stan Ulbrych in gh-136702 ) typing : Before Python 3.14, old-style unions were implemented using the private class typing._UnionGenericAlias . This class is no longer needed for the implementation, but it has been retained for backward compatibility, with removal scheduled for Python 3.17. Users should use documented introspection helpers like typing.get_origin() and typing.get_args() instead of relying on private implementation details. typing.ByteString , deprecated since Python 3.9, is scheduled for removal in Python 3.17. Use isinstance(obj, collections.abc.Buffer) to test if obj implements the buffer protocol at runtime. For use in type annotations, either use Buffer or a union that explicitly specifies the types your code supports (e.g., bytes \| bytearray \| memoryview ). ByteString was originally intended to be an abstract class that would serve as a supertype of both bytes and bytearray . However, since the ABC never had any methods, knowing that an object was an instance of ByteString never actually told you anything useful about the object. Other common buffer types such as memoryview were also never understood as subtypes of ByteString (either at runtime or by static type checkers). See PEP 688 for more details. (Contributed by Shantanu Jain in gh-91896 .) Pending removal in Python 3.18 ¶ decimal : The non-standard and undocumented Decimal format specifier 'N' , which is only supported in the decimal module’s C implementation, has been deprecated since Python 3.13. (Contributed by Serhiy Storchaka in gh-89902 .) Pending removal in Python 3.19 ¶ ctypes : Implicitly switching to the MSVC-compatible struct layout by setting _pack_ but not _layout_ on non-Windows platforms. hashlib : In hash function constructors such as new() or the direct hash-named constructors such as md5() and sha256() , their optional initial data parameter could also be passed a keyword argument named data= or string= in various hashlib implementations. Support for the string keyword argument name is now deprecated and slated for removal in Python 3.19. Before Python 3.13, the string keyword parameter was not correctly supported depending on the backend implementation of hash functions. Prefer passing the initial data as a positional argument for maximum backwards compatibility. Pending removal in Python 3.20 ¶ The __version__ , version and VERSION attributes have been deprecated in these standard library modules and will be removed in Python 3.20. Use sys.version_info instead. argparse csv ctypes ctypes.macholib decimal (use decimal.SPEC_VERSION instead) http.server imaplib ipaddress json logging ( __date__ also deprecated) optparse pickle platform re socketserver tabnanny tkinter.font tkinter.ttk wsgiref.simple_server xml.etree.ElementTree xml.sax.expatreader xml.sax.handler zlib (Contributed by Hugo van Kemenade and Stan Ulbrych in gh-76007 .) Pending removal in future versions ¶ The following APIs will be removed in the future, although there is currently no date scheduled for their removal. argparse : Nesting argument groups and nesting mutually exclusive groups are deprecated. Passing the undocumented keyword argument prefix_chars to add_argument_group() is now deprecated. The argparse.FileType type converter is deprecated. builtins : Generators: throw(type, exc, tb) and athrow(type, exc, tb) signature is deprecated: use throw(exc) and athrow(exc) instead, the single argument signature. Currently Python accepts numeric literals immediately followed by keywords, for example 0in x , 1or x , 0if 1else 2 . It allows confusing and ambiguous expressions like [0x1for x in y] (which can be interpreted as [0x1 for x in y] or [0x1f or x in y] ). A syntax warning is raised if the numeric literal is immediately followed by one of keywords and , else , for , if , in , is and or . In a future release it will be changed to a syntax error. ( gh-87999 ) Support for __index__() and __int__() method returning non-int type: these methods will be required to return an instance of a strict subclass of int . Support for __float__() method returning a strict subclass of float : these methods will be required to return an instance of float . Support for __complex__() method returning a strict subclass of complex : these methods will be required to return an instance of complex . Delegation of int() to __trunc__() method. Passing a complex number as the real or imag argument in the complex() constructor is now deprecated; it should only be passed as a single positional argument. (Contributed by Serhiy Storchaka in gh-109218 .) calendar : calendar.January and calendar.February constants are deprecated and replaced by calendar.JANUARY and calendar.FEBRUARY . (Contributed by Prince Roshan in gh-103636 .) codecs : use open() instead of codecs.open() . ( gh-133038 ) codeobject.co_lnotab : use the codeobject.co_lines() method instead. datetime : utcnow() : use datetime.datetime.now(tz=datetime.UTC) . utcfromtimestamp() : use datetime.datetime.fromtimestamp(timestamp, tz=datetime.UTC) . gettext : Plural value must be an integer. importlib : cache_from_source() debug_override parameter is deprecated: use the optimization parameter instead. importlib.metadata : EntryPoints tuple interface. Implicit None on return values. logging : the warn() method has been deprecated since Python 3.3, use warning() instead. mailbox : Use of StringIO input and text mode is deprecated, use BytesIO and binary mode instead. os : Calling os.register_at_fork() in a multi-threaded process. pydoc.ErrorDuringImport : A tuple value for exc_info parameter is deprecated, use an exception instance. re : More strict rules are now applied for numerical group references and group names in regular expressions. Only sequence of ASCII digits is now accepted as a numerical reference. The group name in bytes patterns and replacement strings can now only contain ASCII letters and digits and underscore. (Contributed by Serhiy Storchaka in gh-91760 .) shutil : rmtree() ’s onerror parameter is deprecated in Python 3.12; use the onexc parameter instead. ssl options and protocols: ssl.SSLContext without protocol argument is deprecated. ssl.SSLContext : set_npn_protocols() and selected_npn_protocol() are deprecated: use ALPN instead. ssl.OP_NO_SSL* options ssl.OP_NO_TLS* options ssl.PROTOCOL_SSLv3 ssl.PROTOCOL_TLS ssl.PROTOCOL_TLSv1 ssl.PROTOCOL_TLSv1_1 ssl.PROTOCOL_TLSv1_2 ssl.TLSVersion.SSLv3 ssl.TLSVersion.TLSv1 ssl.TLSVersion.TLSv1_1 threading methods: threading.Condition.notifyAll() : use notify_all() . threading.Event.isSet() : use is_set() . threading.Thread.isDaemon() , threading.Thread.setDaemon() : use threading.Thread.daemon attribute. threading.Thread.getName() , threading.Thread.setName() : use threading.Thread.name attribute. threading.currentThread() : use threading.current_thread() . threading.activeCount() : use threading.active_count() . typing.Text ( gh-92332 ). The internal class typing._UnionGenericAlias is no longer used to implement typing.Union . To preserve compatibility with users using this private class, a compatibility shim will be provided until at least Python 3.17. (Contributed by Jelle Zijlstra in gh-105499 .) unittest.IsolatedAsyncioTestCase : it is deprecated to return a value that is not None from a test case. urllib.parse deprecated functions: urlparse() instead splitattr() splithost() splitnport() splitpasswd() splitport() splitquery() splittag() splittype() splituser() splitvalue() to_bytes() wsgiref : SimpleHandler.stdout.write() should not do partial writes. xml.etree.ElementTree : Testing the truth value of an Element is deprecated. In a future release it will always return True . Prefer explicit len(elem) or elem is not None tests instead. sys._clear_type_cache() is deprecated: use sys._clear_internal_caches() instead. C API changes ¶ New features ¶ Add PySys_GetAttr() , PySys_GetAttrString() , PySys_GetOptionalAttr() , and PySys_GetOptionalAttrString() functions as replacements for PySys_GetObject() . (Contributed by Serhiy Storchaka in gh-108512 .) Add PyUnstable_Unicode_GET_CACHED_HASH to get the cached hash of a string. See the documentation for caveats. (Contributed by Petr Viktorin in gh-131510 .) Add API for checking an extension module’s ABI compatibility: Py_mod_abi , PyABIInfo_Check() , PyABIInfo_VAR and Py_mod_abi . (Contributed by Petr Viktorin in gh-137210 .) Implement PEP 782 , the PyBytesWriter API . Add functions: PyBytesWriter_Create() PyBytesWriter_Discard() PyBytesWriter_FinishWithPointer() PyBytesWriter_FinishWithSize() PyBytesWriter_Finish() PyBytesWriter_Format() PyBytesWriter_GetData() PyBytesWriter_GetSize() PyBytesWriter_GrowAndUpdatePointer() PyBytesWriter_Grow() PyBytesWriter_Resize() PyBytesWriter_WriteBytes() (Contributed by Victor Stinner in gh-129813 .) Add a new PyImport_CreateModuleFromInitfunc() C-API for creating a module from a spec and initfunc . (Contributed by Itamar Oren in gh-116146 .) Add PyTuple_FromArray() to create a tuple from an array. (Contributed by Victor Stinner in gh-111489 .) Add PyUnstable_Object_Dump() to dump an object to stderr . It should only be used for debugging. (Contributed by Victor Stinner in gh-141070 .) Add PyUnstable_ThreadState_SetStackProtection() and PyUnstable_ThreadState_ResetStackProtection() functions to set the stack protection base address and stack protection size of a Python thread state. (Contributed by Victor Stinner in gh-139653 .) Changed C APIs ¶ If the Py_TPFLAGS_MANAGED_DICT or Py_TPFLAGS_MANAGED_WEAKREF flag is set then Py_TPFLAGS_HAVE_GC must be set too. (Contributed by Sergey Miryanov in gh-134786 ) Porting to Python 3.15 ¶ Private functions promoted to public C APIs: The pythoncapi-compat project can be used to get most of these new functions on Python 3.14 and older. Removed C APIs ¶ Remove deprecated PyUnicode functions: PyUnicode_AsDecodedObject() : Use PyCodec_Decode() instead. PyUnicode_AsDecodedUnicode() : Use PyCodec_Decode() instead; Note that some codecs (for example, “base64”) may return a type other than str , such as bytes . PyUnicode_AsEncodedObject() : Use PyCodec_Encode() instead. PyUnicode_AsEncodedUnicode() : Use PyCodec_Encode() instead; Note that some codecs (for example, “base64”) may return a type other than bytes , such as str . (Contributed by Stan Ulbrych in gh-133612 .) PyImport_ImportModuleNoBlock()	2026-01-13T08:49:46
https://future.forem.com/enter?state=new-user	Welcome! - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Join the Forem Forem is a community of 3,676,891 amazing members Sign up with Apple Sign up with Facebook Sign up with GitHub Sign up with Google Sign up with Twitter (X) Sign up with Email By signing up, you are agreeing to our privacy policy , terms of use and code of conduct . Already have an account? Log in . 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:46
https://open.forem.com/gustavowoltmann18/science-behind-mountain-formation-l5o	Science behind Mountain Formation - Open Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account Open Forem Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Gustavo Woltmann Posted on Jan 4 Science behind Mountain Formation # beginners # learning # science Mountains, with their awe-inspiring peaks and ridges, are the result of dynamic geological processes occurring over millions of years. The formation of mountains, or orogeny, involves tectonic forces, volcanic activity, and erosion, all of which contribute to shaping the Earth’s surface. Mountains not only influence climate and ecosystems but also play a significant role in human culture, history, and settlement patterns. Types of Mountain Formation Mountains are formed through several main processes, which are largely driven by the movement and interaction of the Earth’s tectonic plates. These processes lead to the creation of different types of mountains: fold mountains, fault-block mountains, volcanic mountains, and dome mountains. Fold Mountains: Fold mountains are created when two tectonic plates collide and push layers of Earth’s crust upward into folds. This process is known as compression, where rocks are squeezed and folded over time due to intense pressure. Fold mountains are some of the highest and most extensive mountain ranges on Earth, and they typically feature jagged, towering peaks. Examples: The Himalayas in Asia, formed by the collision of the Indian and Eurasian plates; the Alps in Europe, created by the African and Eurasian plates converging; and the Rockies in North America. Fault-Block Mountains: Fault-block mountains form when large areas of the Earth’s crust are broken up by faults, or fractures. In this type of formation, one block of crust moves up while another block moves downward. This process is driven by tensional forces, which cause the Earth’s crust to stretch and break. The upward-moving blocks become mountains, and the downward-moving blocks become valleys or basins. Examples: The Sierra Nevada mountains in California and the Teton Range in Wyoming. Volcanic Mountains: Volcanic mountains form as a result of volcanic activity, where molten rock (magma) from beneath the Earth’s crust erupts through a vent or fissure and piles up on the surface. Over time, repeated eruptions build up layers of lava and ash, creating volcanic cones that form mountain-like structures. These mountains are typically found near tectonic plate boundaries or at “hot spots” in the Earth’s crust. Examples: Mount Fuji in Japan, Mount Kilimanjaro in Tanzania, and the Cascade Range in the Pacific Northwest. Dome Mountains: Dome mountains are formed when magma pushes the Earth’s crust upward but doesn’t break through the surface. This creates a dome-shaped bulge, which, over time, can erode and leave isolated mountain-like structures. Dome mountains tend to have a rounded shape, unlike the sharp peaks of fold mountains. Examples: The Black Hills in South Dakota and the Adirondack Mountains in New York. The Role of Plate Tectonics The driving force behind most mountain formation is the movement of tectonic plates, the large slabs of rock that make up the Earth’s outer shell. These plates float on the semi-fluid asthenosphere beneath them and are constantly moving, albeit at very slow rates, typically a few centimeters per year. The types of plate boundaries — convergent, divergent, and transform — determine the nature of geological activity in those regions. Convergent Boundaries: When two plates collide, they can produce significant folding, faulting, and volcanic activity, leading to mountain formation. For example, the collision between the Indian and Eurasian plates formed the Himalayas, which continue to grow today due to ongoing tectonic pressure. Divergent Boundaries: Although less common, mountains can also form at divergent boundaries, where plates move apart. This process creates new crust, resulting in underwater mountain chains, such as the Mid-Atlantic Ridge, though it rarely forms large mountains on land. Transform Boundaries: At transform boundaries, where two plates slide past each other, mountains are generally not created. Instead, these regions are more prone to earthquakes, such as along the San Andreas Fault in California. The Role of Erosion and Weathering Once mountains are formed, erosion and weathering play an essential role in shaping them over time. Weathering involves the breakdown of rocks at the surface, while erosion is the removal and transportation of these materials by natural forces such as water, wind, ice, and gravity. Over millions of years, these forces can drastically change the appearance of mountain ranges. Water: Rivers and streams erode mountains by carrying away particles and sediment, carving out valleys and canyons. Water erosion has created dramatic landscapes like the Grand Canyon in the United States. Glaciers: Glaciers, or massive bodies of ice, also play a powerful role in mountain erosion. As glaciers move slowly down mountain slopes, they carve out deep valleys, ridges, and jagged peaks, leaving behind U-shaped valleys and other distinctive formations. Wind and Gravity: Wind can erode rock surfaces, especially in arid regions. Gravity contributes to erosion through rockfalls and landslides, especially in steep mountain regions where weathering weakens rock structures over time. Notable Mountain Ranges Around the World The Himalayas: This range contains the world’s tallest peak, Mount Everest, and was formed from the ongoing collision between the Indian and Eurasian plates. The Himalayas continue to rise due to this tectonic activity. The Andes: Stretching along South America’s western edge, the Andes were formed by the subduction of the oceanic Nazca Plate beneath the South American Plate. The range is the longest continental mountain range in the world. The Alps: Created by the collision of the African and Eurasian plates, the Alps span eight countries in Europe and feature peaks like Mont Blanc. The Rocky Mountains: Extending from Canada to the southwestern United States, the Rockies were formed from a complex process of tectonic plate interactions and volcanic activity. The Appalachian Mountains: Among the oldest mountain ranges in the world, the Appalachians are a product of ancient collisions that once united the continents of North America and Africa. Over time, they have eroded to become more rounded and less jagged. Environmental and Climatic Effects of Mountains Mountains have a significant impact on climate, biodiversity, and human life: Climate: Mountains influence weather patterns by acting as barriers to atmospheric circulation. This leads to what is known as the rain shadow effect, where one side of a mountain range receives heavy rainfall, while the other remains arid. Biodiversity: Mountains create diverse habitats and microclimates, supporting unique ecosystems and a variety of plant and animal life that often adapt to specific altitudes. Human Settlement and Culture: Mountains have shaped human history and culture, influencing settlement patterns, agricultural practices, and trade routes. Mountainous regions are often rich in natural resources, which have historically attracted human habitation despite the challenging terrain. Mountain formation is a dynamic process that has shaped the Earth’s surface over millions of years, creating some of the most breathtaking landscapes and diverse ecosystems on the planet. Driven primarily by tectonic forces, volcanic activity, and erosion, mountains stand as enduring symbols of the Earth’s geological power. Their existence impacts climate, ecosystems, and human cultures around the world, making them invaluable both scientifically and culturally. The continuous movement of tectonic plates and the forces of erosion ensure that mountains will continue to evolve, changing in height and shape over geological time. Top comments (0) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse Gustavo Woltmann Follow Joined Nov 9, 2025 More from Gustavo Woltmann Apophis: The Potential Threat of a Comet Impact on Earth # discuss # science # space # watercooler The Discovery and Development of Electricity: Powering the Modern World # learning # science 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV Open Forem — A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . Open Forem © 2016 - 2026. Where all the other conversations belong Log in Create account	2026-01-13T08:49:46
https://l.facebook.com/l.php?u=https%3A%2F%2Fwww.instagram.com%2F&h=AT1BjByJ_oBKe5igfy0Td8OG1t4fkXHjViRYDCVAm6TDx--53JRdAkDiSxbY3OW_bXcVGmPj7A66n5ubLFP3mu2LI8GW1zc4S3e748DX5mCR0U3GqtMJdw35EhaAkuX3bSoimm_TE52z8P7u	Facebook 나가기 Facebook Notice Facebook 외부의 링크로 이동합니다 이동하려는 링크가 Facebook 외부의 링크입니다: https://www.instagram.com/ 이 링크로 이동하시겠어요? 돌아가기 링크로 이동 한국어 English (US) Tiếng Việt Bahasa Indonesia ภาษาไทย Español 中文(简体) 日本語 Português (Brasil) Français (France) Deutsch 가입하기 로그인 Messenger Facebook Lite 동영상 Meta Pay Meta 스토어 Meta Quest Ray-Ban Meta Meta AI Meta AI 콘텐츠 더 보기 Instagram Threads 투표 정보 센터 개인정보처리방침 개인정보 보호 센터 정보 광고 만들기 페이지 만들기 개발자 채용 정보 쿠키 AdChoices 이용 약관 고객 센터 연락처 업로드 및 비사용자 설정 활동 로그 Meta © 2026	2026-01-13T08:49:46
https://dev.to/cotter/localstorage-vs-cookies-all-you-need-to-know-about-storing-jwt-tokens-securely-in-the-front-end-15id#a-recap-about-access-token-amp-refresh-token	LocalStorage vs Cookies: All You Need To Know About Storing JWT Tokens Securely in The Front-End - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Michelle Marcelline for Cotter Posted on Jul 21, 2020 • Edited on Aug 1, 2020 • Originally published at blog.cotter.app           LocalStorage vs Cookies: All You Need To Know About Storing JWT Tokens Securely in The Front-End # security # webdev # javascript OAuth 2.0, JWT Tokens, and How to Store Them Securely (3 Part Series) 1 What on Earth Is OAuth? ASuper Simple Intro to OAuth 2.0, Access Tokens, and How to Implement It in Your Site 2 LocalStorage vs Cookies: All You Need To Know About Storing JWT Tokens Securely in The Front-End 3 OAuth 2.0 - Before You Start: Pick the Right Flow for Your Website, SPA, Mobile App, TV App, and CLI JWT Tokens are awesome, but how do you store them securely in your front-end? We'll go over the pros and cons of localStorage and Cookies. We went over how OAuth 2.0 works in the last post and we covered how to generate access tokens and refresh tokens. The next question is: how do you store them securely in your front-end? A Recap about Access Token & Refresh Token Access tokens are usually short-lived JWT Tokens, signed by your server, and are included in every HTTP request to your server to authorize the request. Refresh tokens are usually long-lived opaque strings stored in your database and are used to get a new access token when it expires. Where should I store my tokens in the front-end? There are 2 common ways to store your tokens: in localStorage or cookies. There are a lot of debate on which one is better and most people lean toward cookies for being more secure. Let's go over the comparison between localStorage . This article is mainly based on Please Stop Using Local Storage and the comments to this post. Local Storage Pros: It's convenient. It's pure JavaScript and it's convenient. If you don't have a back-end and you're relying on a third-party API, you can't always ask them to set a specific cookie for your site. Works with APIs that require you to put your access token in the header like this: Authorization Bearer ${access_token} . Cons: It's vulnerable to XSS attacks. An XSS attack happens when an attacker can run JavaScript on your website. This means that the attacker can just take the access token that you stored in your localStorage . An XSS attack can happen from a third-party JavaScript code included in your website, like React, Vue, jQuery, Google Analytics, etc. It's almost impossible not to include any third-party libraries in your site. Cookies Pros: The cookie is not accessible via JavaScript; hence, it is not as vulnerable to XSS attacks as localStorage . If you're using httpOnly and secure cookies, that means your cookies cannot be accessed using JavaScript. This means, even if an attacker can run JS on your site, they can't read your access token from the cookie. It's automatically sent in every HTTP request to your server. Cons: Depending on the use case, you might not be able to store your tokens in the cookies. Cookies have a size limit of 4KB. Therefore, if you're using a big JWT Token, storing in the cookie is not an option. There are scenarios where you can't share cookies with your API server or the API requires you to put the access token in the Authorization header. In this case, you won't be able to use cookies to store your tokens. About XSS Attack Local storage is vulnerable because it's easily accessible using JavaScript and an attacker can retrieve your access token and use it later. However, while httpOnly cookies are not accessible using JavaScript, this doesn't mean that by using cookies, you are safe from XSS attacks involving your access token. If an attacker can run JavaScript in your application, then they can just send an HTTP request to your server and that will automatically include your cookies. It's just less convenient for the attacker because they can't read the content of the token although they rarely have to. It might also be more advantageous for the attacker to attack using victim's browser (by just sending that HTTP Request) rather than using the attacker's machine. Cookies and CSRF Attack CSRF Attack is an attack that forces a user to do an unintended request. For example, if a website is accepting an email change request via: POST /email/change HTTP / 1.1 Host : site.com Content-Type : application/x-www-form-urlencoded Content-Length : 50 Cookie : session=abcdefghijklmnopqrstu email=myemail.example.com Enter fullscreen mode Exit fullscreen mode Then an attacker can easily make a form in a malicious website that sends a POST request to https://site.com/email/change with a hidden email field and the session cookie will automatically be included. However, this can be mitigated easily using sameSite flag in your cookie and by including an anti-CSRF token . Conclusion Although cookies still have some vulnerabilities, it's preferable compared to localStorage whenever possible. Why? Both localStorage and cookies are vulnerable to XSS attacks but it's harder for the attacker to do the attack when you're using httpOnly cookies. Cookies are vulnerable to CSRF attacks but it can be mitigated using sameSite flag and anti-CSRF tokens . You can still make it work even if you need to use the Authorization: Bearer header or if your JWT is larger than 4KB. This is also consistent with the recommendation from the OWASP community: Do not store session identifiers in local storage as the data are always accessible by JavaScript. Cookies can mitigate this risk using the httpOnly flag. OWASP: HTML5 Security Cheat Sheet So, how do I use cookies to persists my OAuth 2.0 tokens? As a recap, here are the different ways you can store your tokens: Option 1: Store your access token in localStorage : prone to XSS. Option 2: Store your access token in httpOnly cookie: prone to CSRF but can be mitigated, a bit better in terms of exposure to XSS. Option 3: Store the refresh token in httpOnly cookie: safe from CSRF, a bit better in terms of exposure to XSS. We'll go over how Option 3 works as it is the best out of the 3 options. Store your access token in memory and store your refresh token in the cookie Why is this safe from CSRF? Although a form submit to /refresh_token will work and a new access token will be returned, the attacker can't read the response if they're using an HTML form. To prevent the attacker from successfully making a fetch or AJAX request and read the response, this requires the Authorization Server's CORS policy to be set up correctly to prevent requests from unauthorized websites. So how does this set up work? Step 1: Return Access Token and Refresh Token when the user is authenticated. After the user is authenticated, the Authorization Server will return an access_token and a refresh_token . The access_token will be included in the Response body and the refresh_token will be included in the cookie. Refresh Token cookie setup: Use the httpOnly flag to prevent JavaScript from reading it. Use the secure=true flag so it can only be sent over HTTPS. Use the SameSite=strict flag whenever possible to prevent CSRF. This can only be used if the Authorization Server has the same site as your front-end. If this is not the case, your Authorization Server must set CORS headers in the back-end or use other methods to ensure that the refresh token request can only be done by authorized websites. Step 2: Store the access token in memory Storing the token in-memory means that you put this access token in a variable in your front-end site. Yes, this means that the access token will be gone if the user switches tabs or refresh the site. That's why we have the refresh token. Step 3: Renew access token using the refresh token When the access token is gone or has expired, hit the /refresh_token endpoint and the refresh token that was stored in the cookie in step 1 will be included in the request. You'll get a new access token and can then use that for your API Requests. This means your JWT Token can be larger than 4KB and you can also put it in the Authorization header. That's It! This should cover the basics and help you secure your site. This post is written by the team at Cotter – we are building lightweight, fast, and passwordless login solution for websites and mobile apps. If you're building a login flow for your website or mobile app, these articles might help: What On Earth Is OAuth? A Super Simple Intro to OAuth 2.0, Access Tokens, and How to Implement it in your Site Passwordless Login with Email and JSON Web Token (JWT) Authentication using Next.js Here's How to Integrate Cotter's Magic Link to Your Webflow Site in Less Than 15 minutes! References We referred to several articles when writing this blog, especially from these articles: Please Stop Using Local Storage The Ultimate Guide to handling JWTs on front-end clients (GraphQL) Cookies vs Localstorage for sessions – everything you need to know Questions & Feedback If you need help or have any feedback, feel free to comment here or ping us on Cotter's Slack Channel ! We're here to help. Ready to use Cotter? If you enjoyed this post and want to integrate Cotter into your website or app, you can create a free account and check out our documentation . OAuth 2.0, JWT Tokens, and How to Store Them Securely (3 Part Series) 1 What on Earth Is OAuth? ASuper Simple Intro to OAuth 2.0, Access Tokens, and How to Implement It in Your Site 2 LocalStorage vs Cookies: All You Need To Know About Storing JWT Tokens Securely in The Front-End 3 OAuth 2.0 - Before You Start: Pick the Right Flow for Your Website, SPA, Mobile App, TV App, and CLI Top comments (46) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Collapse Expand   Kasey Speakman Kasey Speakman Kasey Speakman Follow collector of ideas. no one of consequence. Location Huntsville, AL Joined Apr 5, 2017 • Jul 22 '20 • Edited on Jul 24 • Edited Dropdown menu Copy link Hide The part of this discussion I always stumble over is when it is recommended to "just" use anti-CSRF tokens. This is a non-trivial requirement. It is easy for one server -- most of them have built-in libs just like with JWT authentication. However, unlike JWT authentication it is a stateful process. So once you go beyond a single API server (including a fail-over scenario) you have to externalize the issued CSRF tokens into something like Redis (or a DB if you don't mind even more added latency). So all servers can be aware of the issued tokens. This adds another infrastructure piece that needs to be maintained and scaled for load. Edit: I guess people already using session servers are thinking "So what, we already have Redis to track user sessions." But with JWT, user sessions are stateless (just the token they provide and you validate) so this extra infrastructure isn't needed. That's a maintenance cost eliminated. As far as local storage being vulnerable to XSS attacks, OWASP also puts out an XSS Prevention Cheat Sheet . The main attack vector for XSS is when you allow users to directly input HTML/JS and then execute it. Most major frameworks already santize user inputs to prevent this. Modern JavaScript frameworks have pretty good XSS protection built in. OWASP XSS Prevention Cheat Sheet The less common threat that you mentioned was NPM libraries becoming subverted to include XSS attacks. NPM has added auditing tools to report this and warn users. (Edit: Fair point is that people sometimes still use JS libs from CDNs, which may have less scrutiny.) And also Content Security Policy is supported in all major browsers and can prevent attacks and the exfil of token/data even if a script on your site gets compromised. It does not necessarily prevent the compromised script from making calls to your own API. But they would have to be targeting your API specifically to accomplish much. I completely understand the recommendation to use cookies + Secure + HttpOnly + anti-forgery tokens from a security perspective. And as far as I am aware it is superior security to JWT in local storage. But it also has pretty significant constraints. And local storage is not bad, security-wise. It is isolated by domain. XSS attacks are already heavily mitigated by just using a modern JS framework and paying attention to NPM audit warnings. Throw in CSP for good measure. And of course not going out of your way to evaluate user-entered data as HTML/JS/CSS. (If your site functionality requires this, then you probably should use cookie auth and CSP.) Like comment: Like comment: 37  likes Like Comment button Reply Collapse Expand   Putri Karunia Cotter Putri Karunia Cotter Putri Karunia Follow Co-founder of Cotter.app, web dev & design enthusiast. Email putri@typedream.com Location San Francisco Education UC Berkeley Work CTO at Typedream Joined Jun 18, 2020 • Jul 23 '20 Dropdown menu Copy link Hide Hi Kasey, thanks for your comment! I do agree that localStorage is not bad at all, and considering how XSS attacks are already heavily mitigated as you mentioned, it's a valid option. Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   Kasey Speakman Kasey Speakman Kasey Speakman Follow collector of ideas. no one of consequence. Location Huntsville, AL Joined Apr 5, 2017 • Jul 23 '20 Dropdown menu Copy link Hide Hey thanks for the response! Best wishes. Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Todd Matheson Todd Matheson Todd Matheson Follow I'm current a student in frontend dev. I love learning new things, especially in the realm of web development. Also, becoming well acquainted with Rust's borrow checker. Location Bay Area, California Education Current Web Development Student Work Full stack web developer Joined Jan 2, 2019 • Jul 22 '20 Dropdown menu Copy link Hide Great article. Thanks for the in depth research and clear tutorial. Logic was very concise. 😃 Like comment: Like comment: 9  likes Like Comment button Reply Collapse Expand   Michelle Marcelline Cotter Michelle Marcelline Cotter Michelle Marcelline Follow I post about my journey as an immigrant female founder • prev. Typedream (acq. beehiiv) • Y Combibnator W20 • Forbes U30 Location San Francisco Work Co-Founder at The Prompting Company Joined Jun 19, 2020 • Jul 22 '20 Dropdown menu Copy link Hide Happy to help! Feel free to ping me if you have any questions/concerns :) Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Todd Matheson Todd Matheson Todd Matheson Follow I'm current a student in frontend dev. I love learning new things, especially in the realm of web development. Also, becoming well acquainted with Rust's borrow checker. Location Bay Area, California Education Current Web Development Student Work Full stack web developer Joined Jan 2, 2019 • Jul 22 '20 Dropdown menu Copy link Hide Thanks Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Anshul Negi Anshul Negi Anshul Negi Follow Hello there... I Consider Myself A Budding Programmer, Learning Things At Own Pace & Celebrating The Learning Curve. Email anshul.negi.tc@gmail.com Location India Education B.Tech(Computer Science) Work MERN developer at Anshul Negi Joined Dec 14, 2019 • Jul 22 '20 Dropdown menu Copy link Hide Was in a long search for this clarification. Thanks Like comment: Like comment: 6  likes Like Comment button Reply Collapse Expand   Michelle Marcelline Cotter Michelle Marcelline Cotter Michelle Marcelline Follow I post about my journey as an immigrant female founder • prev. Typedream (acq. beehiiv) • Y Combibnator W20 • Forbes U30 Location San Francisco Work Co-Founder at The Prompting Company Joined Jun 19, 2020 • Jul 22 '20 • Edited on Jul 23 • Edited Dropdown menu Copy link Hide Thanks Anshul! Let me know if you want me to discuss any other topics related to Authentication :) Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Anshul Negi Anshul Negi Anshul Negi Follow Hello there... I Consider Myself A Budding Programmer, Learning Things At Own Pace & Celebrating The Learning Curve. Email anshul.negi.tc@gmail.com Location India Education B.Tech(Computer Science) Work MERN developer at Anshul Negi Joined Dec 14, 2019 • Jul 23 '20 Dropdown menu Copy link Hide For sure As for now, this article clears most of the doubts maybe in future if I lost around something related to authentication, will let you know. Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Lucien glue Lucien glue Lucien glue Follow full stack web developer Joined Jul 19, 2020 • Jul 22 '20 Dropdown menu Copy link Hide Thanks for this article, it helped me a lot! Like comment: Like comment: 7  likes Like Comment button Reply Collapse Expand   Michelle Marcelline Cotter Michelle Marcelline Cotter Michelle Marcelline Follow I post about my journey as an immigrant female founder • prev. Typedream (acq. beehiiv) • Y Combibnator W20 • Forbes U30 Location San Francisco Work Co-Founder at The Prompting Company Joined Jun 19, 2020 • Jul 22 '20 • Edited on Jul 23 • Edited Dropdown menu Copy link Hide Thanks Lucien! Let me know if you have any questions :) Like comment: Like comment: 4  likes Like Comment button Reply Collapse Expand   Wayne Smallman Wayne Smallman Wayne Smallman Follow Addicted to learning everything there is (except tax law and OAuth), often to be found contemplating the infinite when not building the Under Cloud. Location Yorkshire, England. Work Owner & Founder at Under Cloud Joined Jun 30, 2019 • Jul 22 '20 • Edited on Jul 22 • Edited Dropdown menu Copy link Hide If you use Express, then it could be worth looking at Express Session and the option to save the data to Redis: app.use( session({ name: 'sessionForApplication', secret: process.env.SESSION_SECRET, saveUninitialized: true, resave: true, cookie: { expires: expiryDate, domain: process.env.APP_DOMAIN }, store: new RedisStore(optionsForRedis) }) ) Enter fullscreen mode Exit fullscreen mode Like comment: Like comment: 10  likes Like Comment button Reply Collapse Expand   Hemant Joshi Hemant Joshi Hemant Joshi Follow Your Friendly Neighbourhood Developer. Location Nainital, India Education Birla Institue Of Apllied Sciences; Work Learning... Joined Mar 31, 2020 • Jul 22 '20 Dropdown menu Copy link Hide Yes, redis is the best one🙂, also cookies would be my second option for JWT based storage Like comment: Like comment: 6  likes Like Comment button Reply Collapse Expand   Putri Karunia Cotter Putri Karunia Cotter Putri Karunia Follow Co-founder of Cotter.app, web dev & design enthusiast. Email putri@typedream.com Location San Francisco Education UC Berkeley Work CTO at Typedream Joined Jun 18, 2020 • Jul 23 '20 Dropdown menu Copy link Hide Hi Wayne, Putri here – Michelle's cofounder. This is very helpful, Express Session with Redis is definitely a great option. Thanks for the comment! Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Wayne Smallman Wayne Smallman Wayne Smallman Follow Addicted to learning everything there is (except tax law and OAuth), often to be found contemplating the infinite when not building the Under Cloud. Location Yorkshire, England. Work Owner & Founder at Under Cloud Joined Jun 30, 2019 • Jul 23 '20 Dropdown menu Copy link Hide A pleasure, and glad to help. Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   m4r4v m4r4v m4r4v Follow I am who I am Location Earth Education Software Engineer, Cibersecurity Analyst, GNU/Linux SysAdmin Work Consultant Joined Jul 7, 2020 • Jul 22 '20 Dropdown menu Copy link Hide Very descriptive and helpful article. Thanks!!! Like comment: Like comment: 7  likes Like Comment button Reply Collapse Expand   Michelle Marcelline Cotter Michelle Marcelline Cotter Michelle Marcelline Follow I post about my journey as an immigrant female founder • prev. Typedream (acq. beehiiv) • Y Combibnator W20 • Forbes U30 Location San Francisco Work Co-Founder at The Prompting Company Joined Jun 19, 2020 • Jul 22 '20 • Edited on Jul 23 • Edited Dropdown menu Copy link Hide Thanks Jorge! Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   Marko Kruljac Marko Kruljac Marko Kruljac Follow Hello world Location Zagreb Joined Feb 27, 2020 • Jul 22 '20 • Edited on Jul 22 • Edited Dropdown menu Copy link Hide Hi Michelle, really great article! What always confused me about httpOnly cookies and JWT is that the frontend app is missing a big benefit of JWT, which is the payload containing claims and possibly other custom data from the backend. This is most often the user's role, which then the app uses to render privileged parts of the UI and so on, or the token expiry information. With httpOnly, this benefit is not utilised - but the cost in increased packet size is still being paid! There are strategies which take option 3 to the extreme, and people have already written great articles about this in details, that the JWT token itself should be split into 2 parts, it's signature in httpOnly, and the rest in a normal JS-accessible cookie. This ofcourse increases the complexity of the backend as well, which now needs to piece together the final JWT from two different incoming sources. I guess this could be option 4. It seems to me, that in order to make good secure use of JWT, considerable complexity on both stacks must be considered. Alternatives are either insecure, or not utilizing the benefits of JWT, which would then just be better off using bearer tokens. Again, thanks for the great article. It really got me thinking about these things and I think a great discussion could be made about the topic. What is your take on splitting the token into two cookies? Does the added complexity justify the security gained? Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Putri Karunia Cotter Putri Karunia Cotter Putri Karunia Follow Co-founder of Cotter.app, web dev & design enthusiast. Email putri@typedream.com Location San Francisco Education UC Berkeley Work CTO at Typedream Joined Jun 18, 2020 • Jul 23 '20 Dropdown menu Copy link Hide Hi Marko, Putri here – Michelle's cofounder. That's an interesting suggestion! I don't quite understand how the frontend would miss being able to read the claims/custom data in the JWT using option 3. By storing the access token in memory, you can decode and read the claims in the frontend whenever the access token is available. When the access token is not available in memory (after a refresh/change tab), you can use a function that will refresh the access token, and now you have the access token available again in memory and you can read/decode it in the frontend. Splitting the JWT might be a useful option if the above solution doesn't help. Let me know what you think :) Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Marko Kruljac Marko Kruljac Marko Kruljac Follow Hello world Location Zagreb Joined Feb 27, 2020 • Jul 23 '20 Dropdown menu Copy link Hide By storing the token in memory, you risk compromising it by means of xss. The damage is contained since the token is short-lived, but still a window of opportunity exists. We can either accept this risk or add considerable complexity to reduce it. What do you think? Like comment: Like comment: 1  like Like Thread Thread   Putri Karunia Cotter Putri Karunia Cotter Putri Karunia Follow Co-founder of Cotter.app, web dev & design enthusiast. Email putri@typedream.com Location San Francisco Education UC Berkeley Work CTO at Typedream Joined Jun 18, 2020 • Jul 23 '20 Dropdown menu Copy link Hide That's true, storing in memory is still prone to XSS attack, it's just harder for the attacker to find it than localStorage. Splitting the JWT into 2 cookies where the signature is in an httpOnly cookie, but the rest of the JWT is accessible to JavaScript makes sense. This means that the frontend can still access JWT except for the signature. I think it's up to the website to determine what kind of attack factor that they're trying to mitigate against to decide whether they need the upgrade in security. Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Pacharapol Withayasakpunt Pacharapol Withayasakpunt Pacharapol Withayasakpunt Follow Currently interested in TypeScript, Vue, Kotlin and Python. Looking forward to learning DevOps, though. Location Thailand Education Yes Joined Oct 30, 2019 • Jul 28 '20 • Edited on Jul 28 • Edited Dropdown menu Copy link Hide I just wonder what is actually accessible by document.cookie ? Secondly would be the implementation. I am interested in all processes from highly-accessible sign-in, to protecting the API endpoint, and the server knows requesters' credentials (for attaching userId in database queries). I currently use Firebase / firebase-admin for these reasons, but I have trouble implementing storing token in cookies . I fear that it might be backend dependent... I will consider your product. Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Putri Karunia Cotter Putri Karunia Cotter Putri Karunia Follow Co-founder of Cotter.app, web dev & design enthusiast. Email putri@typedream.com Location San Francisco Education UC Berkeley Work CTO at Typedream Joined Jun 18, 2020 • Aug 4 '20 Dropdown menu Copy link Hide Hi Pacharapol! Cookies that are marked httpOnly are not accessible from document.cookie , otherwise you can access the cookie from document.cookie . source With our JS SDK (from yarn add cotter ), we actually handle storing the access token in memory and the refresh token in the cookie for you. In short, you can just call: cotter . tokenHandler . getAccessToken () Enter fullscreen mode Exit fullscreen mode and it will: grab the access token from memory if not expired, or automatically refreshes the access token by calling Cotter's refresh token endpoint (where the cookie is included) and return to you a new access token. If you're interested, shoot me a message on Slack and I can help you with any questions. You can find our documentation here . Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   Jaytonic Jaytonic Jaytonic Follow Joined Jan 14, 2020 • Mar 18 '22 Dropdown menu Copy link Hide Nice article, thank you! One thing I'm not sure I totally understood: About "Store your access token in memory and store your refresh token in the cookie". Doesn't that make us again vulnerable to XSS attacks? Because your in-memory token would be available by some injected javascript, no? Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   jonyx jonyx jonyx Follow Senior Software Engineer Joined Nov 8, 2019 • Jul 22 '20 Dropdown menu Copy link Hide Hi, I am so excited about this article, But what if the refresh token takes more than 4KB? Is there any way to increase the space of Cookie? Cookie is reling on the type of Browser? Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Putri Karunia Cotter Putri Karunia Cotter Putri Karunia Follow Co-founder of Cotter.app, web dev & design enthusiast. Email putri@typedream.com Location San Francisco Education UC Berkeley Work CTO at Typedream Joined Jun 18, 2020 • Jul 23 '20 Dropdown menu Copy link Hide Hi Pony, refresh tokens are usually opaque random strings stored in your database, so they shouldn't take more than 4KB. I don't think that there's a way to increase the space, but you might be able to split a large cookie into 2. However some browser limits cookie size per domain, so that wouldn't work. Here's a nice list about cookie limits per browser browsercookielimits.squawky.net/ . Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   jonyx jonyx jonyx Follow Senior Software Engineer Joined Nov 8, 2019 • Jul 23 '20 Dropdown menu Copy link Hide Thank you for your kind support Love to wait for your next post Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Follow Ultra-fullstack software developer. Python, JavaScript, C#, C. Location Earth Education I am a master of science Pronouns He/him/his/his Work Software Engineer Joined May 2, 2017 • Sep 9 '21 Dropdown menu Copy link Hide Hi Putri, Just to let you know that the link in your reply is now dead. Like comment: Like comment: 1  like Like Comment button Reply View full discussion (46 comments) Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse Cotter Follow One-Tap Passwordless Login for your App Are you building a website or an app that needs user signups/logins? Learn how to build user-friendly authentication in just a few minutes . Get Started More from Cotter The Simplest Way to Authorize Github OAuth Apps with Next.js and Cotter # javascript # webdev # github # security How to Make an Interactive Todo List CLI using Python with an Easy Login Mechanism # python # tutorial # security OAuth 2.0 - Before You Start: Pick the Right Flow for Your Website, SPA, Mobile App, TV App, and CLI # javascript # security # webdev # react 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://opensource.org/licenses/review-process/	The License Review process – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Home Licenses The License Review process The License Review process Page created on July 24, 2006 \| Last modified on March 13, 2024 The OSI License Review Process ensures that licenses and software labeled as “Open Source” conform to existing community norms and expectations. All licenses must go through a public review process described below. The OSI Board is happy to consult with entities in advance to help them navigate the process and improve their license, but formal approval requires going through the License Review Process. Purpose of the process Ensure approved licenses conform to the Open Source Definition  and provide software freedom Discourage duplicative and poorly written licenses and those with unexpected requirements Ensure a thorough, transparent and timely review (e.g. within 60 days) Overview of the process Submit the license to license-review mailing list Someone who wishes to have a license reviewed and approved by the OSI submits the license to the license-review mailing list. Anyone can join the license-review mailing list and participate in the license review process. There is also a license-discuss mailing list ; this is for discussion of Open Source in general and we also encourage license submitters to ask for advice on the license-discuss list before formally submitting a license to license-review. To navigate the process, the license submitter should bear in mind that license approval is a consensus process. This means that no one person, including a Board member, has the authority to approve or reject a license nor require a change, no matter how strongly they may state their position. Join the mailing list and follow the reviews The person submitting the license must join the license-review mailing list . When a license is submitted for review, there are often questions for the license submitter. The license submitter should be attentive and responsive to those questions. If they are not, we will assume that they are not interested in participating in the process and the license will be at high risk of rejection.Once a license is submitted, anyone wishing to comment on it will comment on the license-review list. There are likely to be all different kinds of comments made during the license review process. Some of the comments may impact whether the license will be approved and some may not. There might be observations not relevant to approval; praise or criticism of the writing style or policy choices in the license; ideological statements about the license or the OSI’s approval policies more generally; or an explanation why the license fails to meet the requirements for approval. Some discussions can get quite lengthy. Board members and employees of OSI may participate in license review in their individual capacity. When participating in their individual capacity, they are expected to use a non-OSI email address.  Reacting to comments, issuing new license versions There will often be suggestions made for changes to the license. Suggestions are only that; the license submitter should not feel obligated to change the license, although it might be wise to do so if comments are pointing out a reason why the license is unlikely to be approved. However, a license cannot be changed while it is being considered. If the license submitter would like to change the language of the license, the current version of the license should be withdrawn from review and an updated version submitted. We recommend that, if changes are going to be made, that the license submitter wait and collect all the desired changes in a single new submission rather than withdrawing and resubmitting the same license several times. Reaching consensus for a decision The “Decision Date” for a license normally means (a) 60 days after a license is initially submitted to the license-review list for review, or (b) 30 days after submission of a revised version of a license that was previously submitted for review, provided that date is no earlier than 60 days after the original license was submitted. While we will try to adhere to this 60/30 day Decision Date definition, circumstances may require us to extend the Decision Date further. The License Committee observes the ongoing discussion to determine whether it has reached a conclusion and whether there is consensus on approving or rejecting the license. If there is not yet consensus, the License Committee will ask for further discussion in an effort to reach consensus. This process may require that the Decision Day be further extended. Issuing the final decision Upon reaching a consensus, the License Committee Chair will provide recommendations for approval or rejection to the OSI board, copying the License Review list. The Board will then vote on whether to adopt the recommendation of the License Committee. The License Committee Chair will report the Board’s decision to the list. If a license is approved, the OSI website will be updated as appropriate. How to submit a request Licenses being submitted will either be a “legacy” license or a “new” license.  A “legacy” license is one that has been in use for at least five years by more than twenty projects maintained by different unrelated entities. A “new” license is any license that is not a legacy license.If it is a family of licenses, each license must be submitted separately.If the license is in a language other than English, the license submitter must provide a certified translation into English. Request for approval of a legacy license Who may submit a request: Anyone The license submitter must: Submit a copy of the license as an attachment in simple text format. Affirmatively state that the license complies with the Open Source Definition, including specifically affirming it meets OSD 3, 5, 6 and 9. Identify what projects are already using the license. Provide the identity and contact details of the license steward , if known, and of the submitter. The OSI will try to get in touch with the license steward if the license submitter is not the steward. Provide any additional information that the submitter believes would be helpful for license review. For example, approval of the license by Debian, the FSF or the Fedora Project would be relevant to the review process. Provide a unique name for the license, preferably including the version number. If any exist, provide the unique identifier by other projects, like SPDX or ScanCode. Identify any proposed tags for the license (when available; see below regarding tagging). Request for approval of a new license Who may submit a request: Anyone, but the License Steward is preferred. The submitter must be a natural person, ideally on behalf of the License Steward, if the latter is an organization. In addition to the information required for a legacy license , the license submitter must: Describe what gap not filled by currently existing licenses that the new license will fill. Compare it to and contrast it with the most similar OSI-approved license(s). Describe any legal review the license has been through, including whether it was drafted by a lawyer. License approval standards It is not possible to comprehensively list all reasons that a license may or may not be approved. Software changes and the role that a license plays in it might change. There will be times when a license presents an issue never considered before. Members of the license-review list are highly skilled, experienced, and deeply involved in Open Source software. Their consensus that a license does not ensure software freedom may, in some cases, be the justification for rejecting a license even where they cannot identify a specific aspect of the OSD or the approval guidelines below that is not met. Approval of a license with the same or similar terms in the past does not bind the OSI to approval of a newly submitted license. Standard for legacy licenses The license must meet the Open Source Definition . No suggestions for changes to the text of legacy licenses will be considered. The license will be approved, or not, as written. The historical context of the license and the common understanding of its meaning will be considered when deciding whether it can be approved.  Standard for new licenses In addition to meeting the Open Source Definition , the following standards apply to new licenses: The license must be reusable, meaning that it can be used by any licensor without changing the terms or having the terms achieve a different result for a different licensor. The license does not have terms that structurally put the licensor in a more favored position than any licensee. To the extent that any terms are ambiguous, the ambiguity must not have a material effect on the application of the license.  The license must be grammatically and syntactically clear to a speaker of the language of the license.  Every possible variation of the application of the license must meet the OSD. It must be possible to comply with the license on submission. As an example, given the scope of copyleft in the Server Side Public License (SSPL), it is not a license that anyone currently would be able to comply with. The license must fill a gap that currently existing licenses do not fill. The text must be the complete license; overlays like Commons Clause and exceptions like ClassPath will not be approved in isolation from the license they modify. Read the common restrictions that have not been approved, and the reason why they are not approved. License Tagging The OSI is planning to use a tagging system to identify attributes of both currently existing licenses and licenses being submitted. The list of such tags is not yet available. This page was last modified on: March 13, 2024 Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://zh-cn.facebook.com/login/?next=https%3A%2F%2Fwww.facebook.com%2Fshare_channel%2F%3Ftype%3Dreshare%26link%3Dhttps%253A%252F%252Fdev.to%252Ftatyanabayramova%252Fglaucoma-awareness-month-363o%26app_id%3D966242223397117%26source_surface%3Dexternal_reshare%26display%26hashtag	登录 Facebook Notice 登录后才能继续。登录 Facebook 登录后才能继续。登录忘记账户了？或创建新账户中文(简体) 한국어 English (US) Tiếng Việt Bahasa Indonesia ภาษาไทย Español 日本語 Português (Brasil) Français (France) Deutsch 注册登录 Messenger Facebook Lite 视频 Meta Pay Meta 商店 Meta Quest Ray-Ban Meta Meta AI Meta AI 更多内容 Instagram Threads 选民信息中心隐私政策隐私中心关于创建广告创建公共主页开发者招聘信息 Cookie Ad Choices 条款帮助联系人上传和非用户设置动态记录 Meta © 2026	2026-01-13T08:49:46
https://twitter.com/cmosantos1	JavaScript is not available. We’ve detected that JavaScript is disabled in this browser. Please enable JavaScript or switch to a supported browser to continue using x.com. You can see a list of supported browsers in our Help Center. Help Center Terms of Service Privacy Policy Cookie Policy Imprint Ads info © 2026 X Corp. Something went wrong, but don’t fret — let’s give it another shot. Try again Some privacy related extensions may cause issues on x.com. Please disable them and try again.	2026-01-13T08:49:46
https://devcycle.com/pricing#events	Pricing \| DevCycle Product Solutions Resources Pricing Docs Book Demo Login Create Account Powerful Feature Flags. Fair Pricing. DevCycle is affordable on all plans. With all the features your team needs and none you don't. Monthly Use setting Annually (Save 20%) Free $0 No credit card required For small projects, or people that just want to give DevCycle a try. Unlimited Seats Up to 1,000 Client-side MAUs A Monthly Active User (MAU) is a unique user with at least one Client-Side SDK initialization in a month. All the features you need to get started. Get Started Core Features, including Unlimited Seats Unlimited Flags All Integrations A/B Testing MCP Server ...and more Developer $ 10 Per Month, Billed Annually For startups who are trying to improve their development process. Unlimited Seats 1,000 MAUs Included A Monthly Active User (MAU) is a unique user with at least one Client-Side SDK initialization in a month. 10,000 Events per Month Included Pricing Estimate: 1,000 MAUs Create Account Everything in Free, plus AI Generated Feature Summaries AI Generated Schemas Audit Logging Feature Opt-in Flag Schemas Custom Property Schemas Business $ 500 Per Month, Billed Annually For organizations with multiple teams that need permissions. Unlimited Seats 100,000 MAUs Included A Monthly Active User (MAU) is a unique user with at least one Client-Side SDK initialization in a month 500,000 Events per Month Included Pricing Estimate: 100,000 MAUs Create Account Everything in Developer, plus Roles & Permissions Stale Flag Detection Custom Property Storage (EdgeDB) Custom Domain Proxy Enterprise Custom Billed Annually For enterprise teams that have strict governance and SLA requirements. Unlimited Seats Custom plans with no limits Contact our team to build a custom plan suited to your needs. Book a Call Everything in Business, plus Approval Workflows Custom SSO/SAML SCIM Provisioning 3rd Party Data ETL Event Relay Proxy Premium Support Uptime SLA Pricing that grows with your business DevCycle Feature List Free Developer Business Enterprise Pricing Breakdown Base Price Free $12.50 / month $625 / month Custom Client-Side MAUs 1,000 Included 1,000 Included then $7.00 per 1,000 100,000 Included then $2.50 per 1,000 Custom Cloud Config Requests 10,000 / month Included 10,000 / month Included then $6 per 10,000 1,000,000 / month Included then $2 per 10,000 Custom Server Config Requests 100,000 / month Included 100,000 / month Included then $6 per 100,000 10,000,000 / month Included then $2 per 100,000 Custom Events 5,000 / month Included 10,000 / month Included then $1 per 10,000 500,000 / month Included then $0.5 per 10,000 Custom Core Features Feature Flags Unlimited Unlimited Unlimited Unlimited Seats Unlimited Unlimited Unlimited Unlimited Environments Unlimited Unlimited Unlimited Unlimited Projects Unlimited Unlimited Unlimited Unlimited A/B Testing & Experimentation Debugging Tools All Integrations Real-Time Updates Targeting & Segmentation Percentage-Based Rollouts Global Flag State Visibility OpenFeature Support Across All SDKs REST API CLI Advanced Features Variable Types Multi-Step Rollouts Rollouts by Custom Property Reusable Audiences Custom Property Targeting One-Click Self Targeting Flag Name Obfuscation Realtime Updates Feature Opt-in Custom Property Schemas Flag Schemas Stale Flag Detection/Notification EdgeDB (Stored Custom Properties) Roles & Permissions Approval Workflows AI-Enabled Features MCP Server AI Generated Feature Summaries AI Generated Schemas Workflow Tools Embedded Debugging Tools Code Generation Tools Flag Importer Code Pipeline Integrations Code References Webhooks VS Code Extension Terraform Provider Slack App Snowflake Data Sharing 3rd party ETL Security & Compliance SOC 2 Type 2 Certified Audit Logging Custom Domain Proxy SAML SSO SCIM Provisioning SDK Proxy Implementation Support & Service Guarantees Discord Community Email Support Shared Slack Channel Custom Migration Support First Reply SLA Uptime SLA Custom Legal Terms Frequently Asked Questions What is a Monthly Active User (MAU)? A Monthly Active User (MAU) is a unique user ID that has at least one Client-Side SDK initialization in a month. What is a Cloud Config Request? A Cloud Config Request happens on initialization or identification update of a client-side SDK such as web and mobile, as well as all calls to our Bucketing API or our server-side SDKs, when configured to run in cloud-bucketing mode. All of these calls grab the latest Feature Flag value/configuration from DevCycle's Edge Workers. What is a Server Config Request? A Server Config Request is a request to the DevCycle config CDN to fetch the latest project Configuration by any of our local bucketing server-side SDKs whether on startup, via polling or triggered by an SSE event. What is an Event? An Event is a single data point sent to DevCycle using the Track API or Track function in our SDKs. These can be any custom event whether tracking conversions or latency. Events serve as a foundation for creating custom metrics. NOTE: Tracking that is built into the DevCycle SDK does not count against billable events. What is EdgeDB? EdgeDB is a lightning-fast, globally replicated edge storage tool that allows you to store information about your users for future use in Targeting Rules. For example, you can set a custom property when a user performs a key action in your application, and then target based on that property in the future without having to continuously provide that data in the SDK. How are Overages Billed? The Developer and Business plans include a set number of Client-Side MAUs, Cloud Config Requests, Server Config Requests, and Events. If you exceed these limits, you'll be billed monthly at the rate specified for your plan, subject to applicable annual discounts. Build Better Software With DevCycle DevCycle is designed from the ground up to help you ship better software, faster. Sign up today and start improving your software development process. Create Account Book a Demo Footer DevCycle What are Feature Flags? OpenFeature Create a Free Account Request a Demo Pricing Resources Documentation SDKs APIs Integrations Blog Contact Support Company About Us Careers Terms of Service Security & Compliance Privacy Policy Contact Us Discord X GitHub LinkedIn Bluesky © 2026 DevCycle All rights reserved.	2026-01-13T08:49:46
https://docs.python.org/3/whatsnew/3.14.html#whatsnew314-deferred-annotations	What’s new in Python 3.14 — Python 3.14.2 documentation Theme Auto Light Dark Table of Contents What’s new in Python 3.14 Summary – Release highlights New features PEP 649 & PEP 749 : Deferred evaluation of annotations PEP 734 : Multiple interpreters in the standard library PEP 750 : Template string literals PEP 768 : Safe external debugger interface A new type of interpreter Free-threaded mode improvements Improved error messages PEP 784 : Zstandard support in the standard library Asyncio introspection capabilities Concurrent safe warnings control Other language changes Built-ins Command line and environment PEP 758: Allow except and except* expressions without brackets PEP 765: Control flow in finally blocks Incremental garbage collection Default interactive shell New modules Improved modules argparse ast asyncio calendar concurrent.futures configparser contextvars ctypes curses datetime decimal difflib dis errno faulthandler fnmatch fractions functools getopt getpass graphlib heapq hmac http imaplib inspect io json linecache logging.handlers math mimetypes multiprocessing operator os os.path pathlib pdb pickle platform pydoc re socket ssl struct symtable sys sys.monitoring sysconfig tarfile threading tkinter turtle types typing unicodedata unittest urllib uuid webbrowser zipfile Optimizations asyncio base64 bdb difflib gc io pathlib pdb textwrap uuid zlib Removed argparse ast asyncio email importlib.abc itertools pathlib pkgutil pty sqlite3 urllib Deprecated New deprecations Pending removal in Python 3.15 Pending removal in Python 3.16 Pending removal in Python 3.17 Pending removal in Python 3.18 Pending removal in Python 3.19 Pending removal in future versions CPython bytecode changes Pseudo-instructions C API changes Python configuration C API New features in the C API Limited C API changes Removed C APIs Deprecated C APIs Pending removal in Python 3.15 Pending removal in Python 3.16 Pending removal in Python 3.18 Pending removal in future versions Build changes build-details.json Discontinuation of PGP signatures Free-threaded Python is officially supported Binary releases for the experimental just-in-time compiler Porting to Python 3.14 Changes in the Python API Changes in annotations ( PEP 649 and PEP 749 ) Implications for annotated code Implications for readers of __annotations__ Related changes from __future__ import annotations Changes in the C API Notable changes in 3.14.1 Previous topic What’s New in Python Next topic What’s New In Python 3.13 This page Report a bug Show source Navigation index modules \| next \| previous \| Python » 3.14.2 Documentation » What’s New in Python » What’s new in Python 3.14 \| Theme Auto Light Dark \| What’s new in Python 3.14 ¶ Editors : Adam Turner and Hugo van Kemenade This article explains the new features in Python 3.14, compared to 3.13. Python 3.14 was released on 7 October 2025. For full details, see the changelog . See also PEP 745 – Python 3.14 release schedule Summary – Release highlights ¶ Python 3.14 is the latest stable release of the Python programming language, with a mix of changes to the language, the implementation, and the standard library. The biggest changes include template string literals , deferred evaluation of annotations , and support for subinterpreters in the standard library. The library changes include significantly improved capabilities for introspection in asyncio , support for Zstandard via a new compression.zstd module, syntax highlighting in the REPL, as well as the usual deprecations and removals, and improvements in user-friendliness and correctness. This article doesn’t attempt to provide a complete specification of all new features, but instead gives a convenient overview. For full details refer to the documentation, such as the Library Reference and Language Reference . To understand the complete implementation and design rationale for a change, refer to the PEP for a particular new feature; but note that PEPs usually are not kept up-to-date once a feature has been fully implemented. See Porting to Python 3.14 for guidance on upgrading from earlier versions of Python. Interpreter improvements: PEP 649 and PEP 749 : Deferred evaluation of annotations PEP 734 : Multiple interpreters in the standard library PEP 750 : Template strings PEP 758 : Allow except and except* expressions without brackets PEP 765 : Control flow in finally blocks PEP 768 : Safe external debugger interface for CPython A new type of interpreter Free-threaded mode improvements Improved error messages Incremental garbage collection Significant improvements in the standard library: PEP 784 : Zstandard support in the standard library Asyncio introspection capabilities Concurrent safe warnings control Syntax highlighting in the default interactive shell , and color output in several standard library CLIs C API improvements: PEP 741 : Python configuration C API Platform support: PEP 776 : Emscripten is now an officially supported platform , at tier 3 . Release changes: PEP 779 : Free-threaded Python is officially supported PEP 761 : PGP signatures have been discontinued for official releases Windows and macOS binary releases now support the experimental just-in-time compiler Binary releases for Android are now provided New features ¶ PEP 649 & PEP 749 : Deferred evaluation of annotations ¶ The annotations on functions, classes, and modules are no longer evaluated eagerly. Instead, annotations are stored in special-purpose annotate functions and evaluated only when necessary (except if from __future__ import annotations is used). This change is designed to improve performance and usability of annotations in Python in most circumstances. The runtime cost for defining annotations is minimized, but it remains possible to introspect annotations at runtime. It is no longer necessary to enclose annotations in strings if they contain forward references. The new annotationlib module provides tools for inspecting deferred annotations. Annotations may be evaluated in the VALUE format (which evaluates annotations to runtime values, similar to the behavior in earlier Python versions), the FORWARDREF format (which replaces undefined names with special markers), and the STRING format (which returns annotations as strings). This example shows how these formats behave: >>> from annotationlib import get_annotations , Format >>> def func ( arg : Undefined ): ... pass >>> get_annotations ( func , format = Format . VALUE ) Traceback (most recent call last): ... NameError : name 'Undefined' is not defined >>> get_annotations ( func , format = Format . FORWARDREF ) {'arg': ForwardRef('Undefined', owner=<function func at 0x...>)} >>> get_annotations ( func , format = Format . STRING ) {'arg': 'Undefined'} The porting section contains guidance on changes that may be needed due to these changes, though in the majority of cases, code will continue working as-is. (Contributed by Jelle Zijlstra in PEP 749 and gh-119180 ; PEP 649 was written by Larry Hastings.) See also PEP 649 Deferred Evaluation Of Annotations Using Descriptors PEP 749 Implementing PEP 649 PEP 734 : Multiple interpreters in the standard library ¶ The CPython runtime supports running multiple copies of Python in the same process simultaneously and has done so for over 20 years. Each of these separate copies is called an ‘interpreter’. However, the feature had been available only through the C-API . That limitation is removed in Python 3.14, with the new concurrent.interpreters module. There are at least two notable reasons why using multiple interpreters has significant benefits: they support a new (to Python), human-friendly concurrency model true multi-core parallelism For some use cases, concurrency in software improves efficiency and can simplify design, at a high level. At the same time, implementing and maintaining all but the simplest concurrency is often a struggle for the human brain. That especially applies to plain threads (for example, threading ), where all memory is shared between all threads. With multiple isolated interpreters, you can take advantage of a class of concurrency models, like Communicating Sequential Processes (CSP) or the actor model, that have found success in other programming languages, like Smalltalk, Erlang, Haskell, and Go. Think of multiple interpreters as threads but with opt-in sharing. Regarding multi-core parallelism: as of Python 3.12, interpreters are now sufficiently isolated from one another to be used in parallel (see PEP 684 ). This unlocks a variety of CPU-intensive use cases for Python that were limited by the GIL . Using multiple interpreters is similar in many ways to multiprocessing , in that they both provide isolated logical “processes” that can run in parallel, with no sharing by default. However, when using multiple interpreters, an application will use fewer system resources and will operate more efficiently (since it stays within the same process). Think of multiple interpreters as having the isolation of processes with the efficiency of threads. While the feature has been around for decades, multiple interpreters have not been used widely, due to low awareness and the lack of a standard library module. Consequently, they currently have several notable limitations, which are expected to improve significantly now that the feature is going mainstream. Current limitations: starting each interpreter has not been optimized yet each interpreter uses more memory than necessary (work continues on extensive internal sharing between interpreters) there aren’t many options yet for truly sharing objects or other data between interpreters (other than memoryview ) many third-party extension modules on PyPI are not yet compatible with multiple interpreters (all standard library extension modules are compatible) the approach to writing applications that use multiple isolated interpreters is mostly unfamiliar to Python users, for now The impact of these limitations will depend on future CPython improvements, how interpreters are used, and what the community solves through PyPI packages. Depending on the use case, the limitations may not have much impact, so try it out! Furthermore, future CPython releases will reduce or eliminate overhead and provide utilities that are less appropriate on PyPI. In the meantime, most of the limitations can also be addressed through extension modules, meaning PyPI packages can fill any gap for 3.14, and even back to 3.12 where interpreters were finally properly isolated and stopped sharing the GIL . Likewise, libraries on PyPI are expected to emerge for high-level abstractions on top of interpreters. Regarding extension modules, work is in progress to update some PyPI projects, as well as tools like Cython, pybind11, nanobind, and PyO3. The steps for isolating an extension module are found at Isolating Extension Modules . Isolating a module has a lot of overlap with what is required to support free-threading , so the ongoing work in the community in that area will help accelerate support for multiple interpreters. Also added in 3.14: concurrent.futures.InterpreterPoolExecutor . (Contributed by Eric Snow in gh-134939 .) See also PEP 734 PEP 750 : Template string literals ¶ Template strings are a new mechanism for custom string processing. They share the familiar syntax of f-strings but, unlike f-strings, return an object representing the static and interpolated parts of the string, instead of a simple str . To write a t-string, use a 't' prefix instead of an 'f' : >>> variety = 'Stilton' >>> template = t 'Try some {variety} cheese!' >>> type ( template ) <class 'string.templatelib.Template'> Template objects provide access to the static and interpolated (in curly braces) parts of a string before they are combined. Iterate over Template instances to access their parts in order: >>> list ( template ) ['Try some ', Interpolation('Stilton', 'variety', None, ''), ' cheese!'] It’s easy to write (or call) code to process Template instances. For example, here’s a function that renders static parts lowercase and Interpolation instances uppercase: from string.templatelib import Interpolation def lower_upper ( template ): """Render static parts lowercase and interpolations uppercase.""" parts = [] for part in template : if isinstance ( part , Interpolation ): parts . append ( str ( part . value ) . upper ()) else : parts . append ( part . lower ()) return '' . join ( parts ) name = 'Wenslydale' template = t 'Mister {name} ' assert lower_upper ( template ) == 'mister WENSLYDALE' Because Template instances distinguish between static strings and interpolations at runtime, they can be useful for sanitising user input. Writing a html() function that escapes user input in HTML is an exercise left to the reader! Template processing code can provide improved flexibility. For instance, a more advanced html() function could accept a dict of HTML attributes directly in the template: attributes = { 'src' : 'limburger.jpg' , 'alt' : 'lovely cheese' } template = t '<img {attributes} >' assert html ( template ) == '<img src="limburger.jpg" alt="lovely cheese" />' Of course, template processing code does not need to return a string-like result. An even more advanced html() could return a custom type representing a DOM-like structure. With t-strings in place, developers can write systems that sanitise SQL, make safe shell operations, improve logging, tackle modern ideas in web development (HTML, CSS, and so on), and implement lightweight custom business DSLs. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in gh-132661 .) See also PEP 750 . PEP 768 : Safe external debugger interface ¶ Python 3.14 introduces a zero-overhead debugging interface that allows debuggers and profilers to safely attach to running Python processes without stopping or restarting them. This is a significant enhancement to Python’s debugging capabilities, meaning that unsafe alternatives are no longer required. The new interface provides safe execution points for attaching debugger code without modifying the interpreter’s normal execution path or adding any overhead at runtime. Due to this, tools can now inspect and interact with Python applications in real-time, which is a crucial capability for high-availability systems and production environments. For convenience, this interface is implemented in the sys.remote_exec() function. For example: import sys from tempfile import NamedTemporaryFile with NamedTemporaryFile ( mode = 'w' , suffix = '.py' , delete = False ) as f : script_path = f . name f . write ( f 'import my_debugger; my_debugger.connect( { os . getpid () } )' ) # Execute in process with PID 1234 print ( 'Behold! An offering:' ) sys . remote_exec ( 1234 , script_path ) This function allows sending Python code to be executed in a target process at the next safe execution point. However, tool authors can also implement the protocol directly as described in the PEP, which details the underlying mechanisms used to safely attach to running processes. The debugging interface has been carefully designed with security in mind and includes several mechanisms to control access: A PYTHON_DISABLE_REMOTE_DEBUG environment variable. A -X disable-remote-debug command-line option. A --without-remote-debug configure flag to completely disable the feature at build time. (Contributed by Pablo Galindo Salgado, Matt Wozniski, and Ivona Stojanovic in gh-131591 .) See also PEP 768 . A new type of interpreter ¶ A new type of interpreter has been added to CPython. It uses tail calls between small C functions that implement individual Python opcodes, rather than one large C case statement. For certain newer compilers, this interpreter provides significantly better performance. Preliminary benchmarks suggest a geometric mean of 3-5% faster on the standard pyperformance benchmark suite, depending on platform and architecture. The baseline is Python 3.14 built with Clang 19, without this new interpreter. This interpreter currently only works with Clang 19 and newer on x86-64 and AArch64 architectures. However, a future release of GCC is expected to support this as well. This feature is opt-in for now. Enabling profile-guided optimization is highly recommendeded when using the new interpreter as it is the only configuration that has been tested and validated for improved performance. For further information, see --with-tail-call-interp . Note This is not to be confused with tail call optimization of Python functions, which is currently not implemented in CPython. This new interpreter type is an internal implementation detail of the CPython interpreter. It doesn’t change the visible behavior of Python programs at all. It can improve their performance, but doesn’t change anything else. (Contributed by Ken Jin in gh-128563 , with ideas on how to implement this in CPython by Mark Shannon, Garrett Gu, Haoran Xu, and Josh Haberman.) Free-threaded mode improvements ¶ CPython’s free-threaded mode ( PEP 703 ), initially added in 3.13, has been significantly improved in Python 3.14. The implementation described in PEP 703 has been finished, including C API changes, and temporary workarounds in the interpreter were replaced with more permanent solutions. The specializing adaptive interpreter ( PEP 659 ) is now enabled in free-threaded mode, which along with many other optimizations greatly improves its performance. The performance penalty on single-threaded code in free-threaded mode is now roughly 5-10%, depending on the platform and C compiler used. From Python 3.14, when compiling extension modules for the free-threaded build of CPython on Windows, the preprocessor variable Py_GIL_DISABLED now needs to be specified by the build backend, as it will no longer be determined automatically by the C compiler. For a running interpreter, the setting that was used at compile time can be found using sysconfig.get_config_var() . The new -X context_aware_warnings flag controls if concurrent safe warnings control is enabled. The flag defaults to true for the free-threaded build and false for the GIL-enabled build. A new thread_inherit_context flag has been added, which if enabled means that threads created with threading.Thread start with a copy of the Context() of the caller of start() . Most significantly, this makes the warning filtering context established by catch_warnings be “inherited” by threads (or asyncio tasks) started within that context. It also affects other modules that use context variables, such as the decimal context manager. This flag defaults to true for the free-threaded build and false for the GIL-enabled build. (Contributed by Sam Gross, Matt Page, Neil Schemenauer, Thomas Wouters, Donghee Na, Kirill Podoprigora, Ken Jin, Itamar Oren, Brett Simmers, Dino Viehland, Nathan Goldbaum, Ralf Gommers, Lysandros Nikolaou, Kumar Aditya, Edgar Margffoy, and many others. Some of these contributors are employed by Meta, which has continued to provide significant engineering resources to support this project.) Improved error messages ¶ The interpreter now provides helpful suggestions when it detects typos in Python keywords. When a word that closely resembles a Python keyword is encountered, the interpreter will suggest the correct keyword in the error message. This feature helps programmers quickly identify and fix common typing mistakes. For example: >>> whille True : ... pass Traceback (most recent call last): File "<stdin>" , line 1 whille True : ^^^^^^ SyntaxError : invalid syntax. Did you mean 'while'? While the feature focuses on the most common cases, some variations of misspellings may still result in regular syntax errors. (Contributed by Pablo Galindo in gh-132449 .) elif statements that follow an else block now have a specific error message. (Contributed by Steele Farnsworth in gh-129902 .) >>> if who == "me" : ... print ( "It's me!" ) ... else : ... print ( "It's not me!" ) ... elif who is None : ... print ( "Who is it?" ) File "<stdin>", line 5 elif who is None: ^^^^ SyntaxError: 'elif' block follows an 'else' block If a statement is passed to the Conditional expressions after else , or one of pass , break , or continue is passed before if , then the error message highlights where the expression is required. (Contributed by Sergey Miryanov in gh-129515 .) >>> x = 1 if True else pass Traceback (most recent call last): File "<string>" , line 1 x = 1 if True else pass ^^^^ SyntaxError : expected expression after 'else', but statement is given >>> x = continue if True else break Traceback (most recent call last): File "<string>" , line 1 x = continue if True else break ^^^^^^^^ SyntaxError : expected expression before 'if', but statement is given When incorrectly closed strings are detected, the error message suggests that the string may be intended to be part of the string. (Contributed by Pablo Galindo in gh-88535 .) >>> "The interesting object " The important object " is very important" Traceback (most recent call last): SyntaxError : invalid syntax. Is this intended to be part of the string? When strings have incompatible prefixes, the error now shows which prefixes are incompatible. (Contributed by Nikita Sobolev in gh-133197 .) >>> ub 'abc' File "<python-input-0>" , line 1 ub 'abc' ^^ SyntaxError : 'u' and 'b' prefixes are incompatible Improved error messages when using as with incompatible targets in: Imports: import ... as ... From imports: from ... import ... as ... Except handlers: except ... as ... Pattern-match cases: case ... as ... (Contributed by Nikita Sobolev in gh-123539 , gh-123562 , and gh-123440 .) Improved error message when trying to add an instance of an unhashable type to a dict or set . (Contributed by CF Bolz-Tereick and Victor Stinner in gh-132828 .) >>> s = set () >>> s . add ({ 'pages' : 12 , 'grade' : 'A' }) Traceback (most recent call last): File "<python-input-1>" , line 1 , in <module> s . add ({ 'pages' : 12 , 'grade' : 'A' }) ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError : cannot use 'dict' as a set element (unhashable type: 'dict') >>> d = {} >>> l = [ 1 , 2 , 3 ] >>> d [ l ] = 12 Traceback (most recent call last): File "<python-input-4>" , line 1 , in <module> d [ l ] = 12 ~^^^ TypeError : cannot use 'list' as a dict key (unhashable type: 'list') Improved error message when an object supporting the synchronous context manager protocol is entered using async with instead of with , and vice versa for the asynchronous context manager protocol. (Contributed by Bénédikt Tran in gh-128398 .) PEP 784 : Zstandard support in the standard library ¶ The new compression package contains modules compression.lzma , compression.bz2 , compression.gzip and compression.zlib which re-export the lzma , bz2 , gzip and zlib modules respectively. The new import names under compression are the preferred names for importing these compression modules from Python 3.14. However, the existing modules names have not been deprecated. Any deprecation or removal of the existing compression modules will occur no sooner than five years after the release of 3.14. The new compression.zstd module provides compression and decompression APIs for the Zstandard format via bindings to Meta’s zstd library . Zstandard is a widely adopted, highly efficient, and fast compression format. In addition to the APIs introduced in compression.zstd , support for reading and writing Zstandard compressed archives has been added to the tarfile , zipfile , and shutil modules. Here’s an example of using the new module to compress some data: from compression import zstd import math data = str ( math . pi ) . encode () * 20 compressed = zstd . compress ( data ) ratio = len ( compressed ) / len ( data ) print ( f "Achieved compression ratio of { ratio } " ) As can be seen, the API is similar to the APIs of the lzma and bz2 modules. (Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in gh-132983 .) See also PEP 784 . Asyncio introspection capabilities ¶ Added a new command-line interface to inspect running Python processes using asynchronous tasks, available via python -m asyncio ps PID or python -m asyncio pstree PID . The ps subcommand inspects the given process ID (PID) and displays information about currently running asyncio tasks. It outputs a task table: a flat listing of all tasks, their names, their coroutine stacks, and which tasks are awaiting them. The pstree subcommand fetches the same information, but instead renders a visual async call tree, showing coroutine relationships in a hierarchical format. This command is particularly useful for debugging long-running or stuck asynchronous programs. It can help developers quickly identify where a program is blocked, what tasks are pending, and how coroutines are chained together. For example given this code: import asyncio async def play_track ( track ): await asyncio . sleep ( 5 ) print ( f '🎵 Finished: { track } ' ) async def play_album ( name , tracks ): async with asyncio . TaskGroup () as tg : for track in tracks : tg . create_task ( play_track ( track ), name = track ) async def main (): async with asyncio . TaskGroup () as tg : tg . create_task ( play_album ( 'Sundowning' , [ 'TNDNBTG' , 'Levitate' ]), name = 'Sundowning' ) tg . create_task ( play_album ( 'TMBTE' , [ 'DYWTYLM' , 'Aqua Regia' ]), name = 'TMBTE' ) if __name__ == '__main__' : asyncio . run ( main ()) Executing the new tool on the running process will yield a table like this: python -m asyncio ps 12345 tid task id task name coroutine stack awaiter chain awaiter name awaiter id ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 1935500 0x7fc930c18050 Task-1 TaskGroup._aexit -> TaskGroup.__aexit__ -> main 0x0 1935500 0x7fc930c18230 Sundowning TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> main Task-1 0x7fc930c18050 1935500 0x7fc93173fa50 TMBTE TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> main Task-1 0x7fc930c18050 1935500 0x7fc93173fdf0 TNDNBTG sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album Sundowning 0x7fc930c18230 1935500 0x7fc930d32510 Levitate sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album Sundowning 0x7fc930c18230 1935500 0x7fc930d32890 DYWTYLM sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album TMBTE 0x7fc93173fa50 1935500 0x7fc93161ec30 Aqua Regia sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album TMBTE 0x7fc93173fa50 or a tree like this: python -m asyncio pstree 12345 └── ( T ) Task-1 └── main example.py:13 └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 ├── ( T ) Sundowning │ └── album example.py:8 │ └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 │ └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 │ ├── ( T ) TNDNBTG │ │ └── play example.py:4 │ │ └── sleep Lib/asyncio/tasks.py:702 │ └── ( T ) Levitate │ └── play example.py:4 │ └── sleep Lib/asyncio/tasks.py:702 └── ( T ) TMBTE └── album example.py:8 └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 ├── ( T ) DYWTYLM │ └── play example.py:4 │ └── sleep Lib/asyncio/tasks.py:702 └── ( T ) Aqua Regia └── play example.py:4 └── sleep Lib/asyncio/tasks.py:702 If a cycle is detected in the async await graph (which could indicate a programming issue), the tool raises an error and lists the cycle paths that prevent tree construction: python -m asyncio pstree 12345 ERROR: await-graph contains cycles - cannot print a tree! cycle: Task-2 → Task-3 → Task-2 (Contributed by Pablo Galindo, Łukasz Langa, Yury Selivanov, and Marta Gomez Macias in gh-91048 .) Concurrent safe warnings control ¶ The warnings.catch_warnings context manager will now optionally use a context variable for warning filters. This is enabled by setting the context_aware_warnings flag, either with the -X command-line option or an environment variable. This gives predictable warnings control when using catch_warnings combined with multiple threads or asynchronous tasks. The flag defaults to true for the free-threaded build and false for the GIL-enabled build. (Contributed by Neil Schemenauer and Kumar Aditya in gh-130010 .) Other language changes ¶ All Windows code pages are now supported as ‘cpXXX’ codecs on Windows. (Contributed by Serhiy Storchaka in gh-123803 .) Implement mixed-mode arithmetic rules combining real and complex numbers as specified by the C standard since C99. (Contributed by Sergey B Kirpichev in gh-69639 .) More syntax errors are now detected regardless of optimisation and the -O command-line option. This includes writes to __debug__ , incorrect use of await , and asynchronous comprehensions outside asynchronous functions. For example, python -O -c 'assert (__debug__ := 1)' or python -O -c 'assert await 1' now produce SyntaxError s. (Contributed by Irit Katriel and Jelle Zijlstra in gh-122245 & gh-121637 .) When subclassing a pure C type, the C slots for the new type are no longer replaced with a wrapped version on class creation if they are not explicitly overridden in the subclass. (Contributed by Tomasz Pytel in gh-132284 .) Built-ins ¶ The bytes.fromhex() and bytearray.fromhex() methods now accept ASCII bytes and bytes-like objects . (Contributed by Daniel Pope in gh-129349 .) Add class methods float.from_number() and complex.from_number() to convert a number to float or complex type correspondingly. They raise a TypeError if the argument is not a real number. (Contributed by Serhiy Storchaka in gh-84978 .) Support underscore and comma as thousands separators in the fractional part for floating-point presentation types of the new-style string formatting (with format() or f-strings ). (Contributed by Sergey B Kirpichev in gh-87790 .) The int() function no longer delegates to __trunc__() . Classes that want to support conversion to int() must implement either __int__() or __index__() . (Contributed by Mark Dickinson in gh-119743 .) The map() function now has an optional keyword-only strict flag like zip() to check that all the iterables are of equal length. (Contributed by Wannes Boeykens in gh-119793 .) The memoryview type now supports subscription, making it a generic type . (Contributed by Brian Schubert in gh-126012 .) Using NotImplemented in a boolean context will now raise a TypeError . This has raised a DeprecationWarning since Python 3.9. (Contributed by Jelle Zijlstra in gh-118767 .) Three-argument pow() now tries calling __rpow__() if necessary. Previously it was only called in two-argument pow() and the binary power operator. (Contributed by Serhiy Storchaka in gh-130104 .) super objects are now copyable and pickleable . (Contributed by Serhiy Storchaka in gh-125767 .) Command line and environment ¶ The import time flag can now track modules that are already loaded (‘cached’), via the new -X importtime=2 . When such a module is imported, the self and cumulative times are replaced by the string cached . Values above 2 for -X importtime are now reserved for future use. (Contributed by Noah Kim and Adam Turner in gh-118655 .) The command-line option -c now automatically dedents its code argument before execution. The auto-dedentation behavior mirrors textwrap.dedent() . (Contributed by Jon Crall and Steven Sun in gh-103998 .) -J is no longer a reserved flag for Jython , and now has no special meaning. (Contributed by Adam Turner in gh-133336 .) PEP 758: Allow except and except* expressions without brackets ¶ The except and except* expressions now allow brackets to be omitted when there are multiple exception types and the as clause is not used. For example: try : connect_to_server () except TimeoutError , ConnectionRefusedError : print ( 'The network has ceased to be!' ) (Contributed by Pablo Galindo and Brett Cannon in PEP 758 and gh-131831 .) PEP 765: Control flow in finally blocks ¶ The compiler now emits a SyntaxWarning when a return , break , or continue statement have the effect of leaving a finally block. This change is specified in PEP 765 . In situations where this change is inconvenient (such as those where the warnings are redundant due to code linting), the warning filter can be used to turn off all syntax warnings by adding ignore::SyntaxWarning as a filter. This can be specified in combination with a filter that converts other warnings to errors (for example, passing -Werror -Wignore::SyntaxWarning as CLI options, or setting PYTHONWARNINGS=error,ignore::SyntaxWarning ). Note that applying such a filter at runtime using the warnings module will only suppress the warning in code that is compiled after the filter is adjusted. Code that is compiled prior to the filter adjustment (for example, when a module is imported) will still emit the syntax warning. (Contributed by Irit Katriel in gh-130080 .) Incremental garbage collection ¶ The cycle garbage collector is now incremental. This means that maximum pause times are reduced by an order of magnitude or more for larger heaps. There are now only two generations: young and old. When gc.collect() is not called directly, the GC is invoked a little less frequently. When invoked, it collects the young generation and an increment of the old generation, instead of collecting one or more generations. The behavior of gc.collect() changes slightly: gc.collect(1) : Performs an increment of garbage collection, rather than collecting generation 1. Other calls to gc.collect() are unchanged. (Contributed by Mark Shannon in gh-108362 .) Default interactive shell ¶ The default interactive shell now highlights Python syntax. The feature is enabled by default, save if PYTHON_BASIC_REPL or any other environment variable that disables colour is set. See Controlling color for details. The default color theme for syntax highlighting strives for good contrast and exclusively uses the 4-bit VGA standard ANSI color codes for maximum compatibility. The theme can be customized using an experimental API _colorize.set_theme() . This can be called interactively or in the PYTHONSTARTUP script. Note that this function has no stability guarantees, and may change or be removed. (Contributed by Łukasz Langa in gh-131507 .) The default interactive shell now supports import auto-completion. This means that typing import co and pressing <Tab> will suggest modules starting with co . Similarly, typing from concurrent import i will suggest submodules of concurrent starting with i . Note that autocompletion of module attributes is not currently supported. (Contributed by Tomas Roun in gh-69605 .) New modules ¶ annotationlib : For introspecting annotations . See PEP 749 for more details. (Contributed by Jelle Zijlstra in gh-119180 .) compression (including compression.zstd ): A package for compression-related modules, including a new module to support the Zstandard compression format. See PEP 784 for more details. (Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in gh-132983 .) concurrent.interpreters : Support for multiple interpreters in the standard library. See PEP 734 for more details. (Contributed by Eric Snow in gh-134939 .) string.templatelib : Support for template string literals (t-strings). See PEP 750 for more details. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in gh-132661 .) Improved modules ¶ argparse ¶ The default value of the program name for argparse.ArgumentParser now reflects the way the Python interpreter was instructed to find the __main__ module code. (Contributed by Serhiy Storchaka and Alyssa Coghlan in gh-66436 .) Introduced the optional suggest_on_error parameter to argparse.ArgumentParser , enabling suggestions for argument choices and subparser names if mistyped by the user. (Contributed by Savannah Ostrowski in gh-124456 .) Enable color for help text, which can be disabled with the optional color parameter to argparse.ArgumentParser . This can also be controlled by environment variables . (Contributed by Hugo van Kemenade in gh-130645 .) ast ¶ Add compare() , a function for comparing two ASTs. (Contributed by Batuhan Taskaya and Jeremy Hylton in gh-60191 .) Add support for copy.replace() for AST nodes. (Contributed by Bénédikt Tran in gh-121141 .) Docstrings are now removed from an optimized AST in optimization level 2. (Contributed by Irit Katriel in gh-123958 .) The repr() output for AST nodes now includes more information. (Contributed by Tomas Roun in gh-116022 .) When called with an AST as input, the parse() function now always verifies that the root node type is appropriate. (Contributed by Irit Katriel in gh-130139 .) Add new options to the command-line interface: --feature-version , --optimize , and --show-empty . (Contributed by Semyon Moroz in gh-133367 .) asyncio ¶ The function and methods named create_task() now take an arbitrary list of keyword arguments. All keyword arguments are passed to the Task constructor or the custom task factory. (See set_task_factory() for details.) The name and context keyword arguments are no longer special; the name should now be set using the name keyword argument of the factory, and context may be None . This affects the following function and methods: asyncio.create_task() , asyncio.loop.create_task() , asyncio.TaskGroup.create_task() . (Contributed by Thomas Grainger in gh-128307 .) There are two new utility functions for introspecting and printing a program’s call graph: capture_call_graph() and print_call_graph() . See Asyncio introspection capabilities for more details. (Contributed by Yury Selivanov, Pablo Galindo Salgado, and Łukasz Langa in gh-91048 .) calendar ¶ By default, today’s date is highlighted in color in calendar ’s command-line text output. This can be controlled by environment variables . (Contributed by Hugo van Kemenade in gh-128317 .) concurrent.futures ¶ Add a new executor class, InterpreterPoolExecutor , which exposes multiple Python interpreters in the same process (‘subinterpreters’) to Python code. This uses a pool of independent Python interpreters to execute calls asynchronously. This is separate from the new interpreters module introduced by PEP 734 . (Contributed by Eric Snow in gh-124548 .) On Unix platforms other than macOS, ‘forkserver’ is now the default start method for ProcessPoolExecutor (replacing ‘fork’ ). This change does not affect Windows or macOS, where ‘spawn’ remains the default start method. If the threading incompatible fork method is required, you must explicitly request it by supplying a multiprocessing context mp_context to ProcessPoolExecutor . See forkserver restrictions for information and differences with the fork method and how this change may affect existing code with mutable global shared variables and/or shared objects that can not be automatically pickled . (Contributed by Gregory P. Smith in gh-84559 .) Add two new methods to ProcessPoolExecutor , terminate_workers() and kill_workers() , as ways to terminate or kill all living worker processes in the given pool. (Contributed by Charles Machalow in gh-130849 .) Add the optional buffersize parameter to Executor.map to limit the number of submitted tasks whose results have not yet been yielded. If the buffer is full, iteration over the iterables pauses until a result is yielded from the buffer. (Contributed by Enzo Bonnal and Josh Rosenberg in gh-74028 .) configparser ¶ configparser will no longer write config files it cannot read, to improve security. Attempting to write() keys containing delimiters or beginning with the section header pattern will raise an InvalidWriteError . (Contributed by Jacob Lincoln in gh-129270 .) contextvars ¶ Support the context manager protocol for Token objects. (Contributed by Andrew Svetlov in gh-129889 .) ctypes ¶ The layout of bit fields in Structure and Union objects is now a closer match to platform defaults (GCC/Clang or MSVC). In particular, fields no longer overlap. (Contributed by Matthias Görgens in gh-97702 .) The Structure._layout_ class attribute can now be set to help match a non-default ABI. (Contributed by Petr Viktorin in gh-97702 .) The class of Structure / Union field descriptors is now available as CField , and has new attributes to aid debugging and introspection. (Contributed by Petr Viktorin in gh-128715 .) On Windows, the COMError exception is now public. (Contributed by Jun Komoda in gh-126686 .) On Windows, the CopyComPointer() function is now public. (Contributed by Jun Komoda in gh-127275 .) Add memoryview_at() , a function to create a memoryview object that refers to the supplied pointer and length. This works like ctypes.string_at() except it avoids a buffer copy, and is typically useful when implementing pure Python callback functions that are passed dynamically-sized buffers. (Contributed by Rian Hunter in gh-112018 .) Complex types, c_float_complex , c_double_complex , and c_longdouble_complex , are now available if both the compiler and the libffi library support complex C types. (Contributed by Sergey B Kirpichev in gh-61103 .) Add ctypes.util.dllist() for listing the shared libraries loaded by the current process. (Contributed by Brian Ward in gh-119349 .) Move ctypes.POINTER() types cache from a global internal cache ( _pointer_type_cache ) to the _CData.__pointer_type__ attribute of the corresponding ctypes types. This will stop the cache from growing without limits in some situations. (Contributed by Sergey Miryanov in gh-100926 .) The py_object type now supports subscription, making it a generic type . (Contributed by Brian Schubert in gh-132168 .) ctypes now supports free-threading builds . (Contributed by Kumar Aditya and Peter Bierma in gh-127945 .) curses ¶ Add the assume_default_colors() function, a refinement of the use_default_colors() function which allows changing the color pair 0 . (Contributed by Serhiy Storchaka in gh-133139 .) datetime ¶ Add the strptime() method to the datetime.date and datetime.time classes. (Contributed by Wannes Boeykens in gh-41431 .) decimal ¶ Add Decimal.from_number() as an alternative constructor for Decimal . (Contributed by Serhiy Storchaka in gh-121798 .) Expose IEEEContext() to support creation of contexts corresponding to the IEEE 754 (2008) decimal interchange formats. (Contributed by Sergey B Kirpichev in gh-53032 .) difflib ¶ Comparison pages with highlighted changes generated by the HtmlDiff class now support ‘dark mode’. (Contributed by Jiahao Li in gh-129939 .) dis ¶ Add support for rendering full source location information of instructions , rather than only the line number. This feature is added to the following interfaces via the show_positions keyword argument: dis.Bytecode dis.dis() dis.distb() dis.disassemble() This feature is also exposed via dis --show-positions . (Contributed by Bénédikt Tran in gh-123165 .) Add the dis --specialized command-line option to show specialized bytecode. (Contributed by Bénédikt Tran in gh-127413 .) errno ¶ Add the EHWPOISON error code constant. (Contributed by James Roy in gh-126585 .) faulthandler ¶ Add support for printing the C stack trace on systems that support it via the new dump_c_stack() function or via the c_stack argument in faulthandler.enable() . (Contributed by Peter Bierma in gh-127604 .) fnmatch ¶ Add filterfalse() , a function to reject names matching a given pattern. (Contributed by Bénédikt Tran in gh-74598 .) fractions ¶ A Fraction object may now be constructed from any object with the as_integer_ratio() method. (Contributed by Serhiy Storchaka in gh-82017 .) Add Fraction.from_number() as an alternative constructor for Fraction . (Contributed by Serhiy Storchaka in gh-121797 .) functools ¶ Add the Placeholder sentinel. This may be used with the partial() or partialmethod() functions to reserve a place for positional arguments in the returned partial object . (Contributed by Dominykas Grigonis in gh-119127 .) Allow the initial parameter of reduce() to be passed as a keyword argument. (Contributed by Sayandip Dutta in gh-125916 .) getopt ¶ Add support for options with optional arguments. (Contributed by Serhiy Storchaka in gh-126374 .) Add support for returning intermixed options and non-option arguments in order. (Contributed by Serhiy Storchaka in gh-126390 .) getpass ¶ Support keyboard feedback in the getpass() function via the keyword-only optional argument echo_char . Placeholder characters are rendered whenever a character is entered, and removed when a character is deleted. (Contributed by Semyon Moroz in gh-77065 .) graphlib ¶ Allow TopologicalSorter.prepare() to be called more than once as long as sorting has not started. (Contributed by Daniel Pope in gh-130914 .) heapq ¶ The heapq module has improved support for working with max-heaps, via the following new functions: heapify_max() heappush_max() heappop_max() heapreplace_max() heappushpop_max() hmac ¶ Add a built-in implementation for HMAC ( RFC 2104 ) using formally verified code from the HACL* project. This implementation is used as a fallback when the OpenSSL implementation of HMAC is not available. (Contributed by Bénédikt Tran in gh-99108 .) http ¶ Directory lists and error pages generated by the http.server module allow the browser to apply its default dark mode. (Contributed by Yorik Hansen in gh-123430 .) The http.server module now supports serving over HTTPS using the http.server.HTTPSServer class. This functionality is exposed by the command-line interface ( python -m http.server ) through the following options: --tls-cert <path> : Path to the TLS certificate file. --tls-key <path> : Optional path to the private key file. --tls-password-file <path> : Optional path to the password file for the private key. (Contributed by Semyon Moroz in gh-85162 .) imaplib ¶ Add IMAP4.idle() , implementing the IMAP4 IDLE command as defined in RFC 2177 . (Contributed by Forest in gh-55454 .) inspect ¶ signature() takes a new argument annotation_format to control the annotationlib.Format used for representing annotations. (Contributed by Jelle Zijlstra in gh-101552 .) Signature.format() takes a new argument unquote_annotations . If true, string annotations are displayed without surrounding quotes. (Contributed by Jelle Zijlstra in gh-101552 .) Add function ispackage() to determine whether an object is a package or not. (Contributed by Zhikang Yan in gh-125634 .) io ¶ Reading text from a non-blocking stream with read may now raise a BlockingIOError if the operation cannot immediately return bytes. (Contributed by Giovanni Siragusa in gh-109523 .) Add the Reader and Writer protocols as simpler alternatives to the pseudo-protocols typing.IO , typing.TextIO , and typing.BinaryIO . (Contributed by Sebastian Rittau in gh-127648 .) json ¶ Add exception notes for JSON serialization errors that allow identifying the source of the error. (Contributed by Serhiy Storchaka in gh-122163 .) Allow using the json module as a script using the -m switch: python -m json . This is now preferred to python -m json.tool , which is soft deprecated . See the JSON command-line interface documentation. (Contributed by Trey Hunner in gh-122873 .) By default, the output of the JSON command-line interface is highlighted in color. This can be controlled by environment variables . (Contributed by Tomas Roun in gh-131952 .) linecache ¶ getline() can now retrieve source code for frozen modules. (Contributed by Tian Gao in gh-131638 .) logging.handlers ¶ QueueListener objects now support the context manager protocol. (Contributed by Charles Machalow in gh-132106 .) QueueListener.start now raises a RuntimeError if the listener is already started. (Contributed by Charles Machalow in gh-132106 .) math ¶ Added more detailed error messages for domain errors in the module. (Contributed by Charlie Zhao and Sergey B Kirpichev in gh-101410 .) mimetypes ¶ Add a public command-line for the module, invoked via python -m mimetypes . (Contributed by Oleg Iarygin and Hugo van Kemenade in gh-93096 .) Add several new MIME types based on RFCs and common usage: Microsoft and RFC 8081 MIME types for fonts Embedded OpenType: application/vnd.ms-fontobject OpenType Layout (OTF) font/otf TrueType: font/ttf WOFF 1.0 font/woff WOFF 2.0 font/woff2 RFC 9559	2026-01-13T08:49:46
https://dev.to/t/typescript#main-content	TypeScript - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close TypeScript Follow Hide Optional static type-checking for JavaScript. Create Post submission guidelines Client-side, server-side, WASM, deno, it doesn't matter. This tag should be used for anything TypeScript focused. about #typescript For more information about TypeScript, visit the official site https://www.typescriptlang.org . Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Building Browser Extensions with WXT + Angular Suguru Inatomi Suguru Inatomi Suguru Inatomi Follow Jan 12 Building Browser Extensions with WXT + Angular # angular # typescript # web # extensions Comments Add Comment 4 min read Angular Addicts #45: Signal Form guides, AI integrations & more Gergely Szerovay Gergely Szerovay Gergely Szerovay Follow for This is Angular Jan 13 Angular Addicts #45: Signal Form guides, AI integrations & more # angular # typescript # javascript 1 reaction Comments Add Comment 4 min read The Ultimate Guide to Drizzle ORM + PostgreSQL (2025 Edition) Sameer Saleem Sameer Saleem Sameer Saleem Follow Jan 13 The Ultimate Guide to Drizzle ORM + PostgreSQL (2025 Edition) # webdev # drizzle # postgres # typescript Comments Add Comment 3 min read Your CLI's completion should know what options you've already typed Hong Minhee Hong Minhee Hong Minhee Follow Jan 13 Your CLI's completion should know what options you've already typed # typescript # javascript # cli # terminal Comments Add Comment 4 min read Building Chalkboard: Open Source Billiard Hall Management Setasena Randata Setasena Randata Setasena Randata Follow Jan 13 Building Chalkboard: Open Source Billiard Hall Management # opensource # buildinpublic # typescript # nextjs Comments Add Comment 3 min read Building a LinkedIn Outreach Agent with LangGraph and ConnectSafely.ai AMAAN SARFARAZ AMAAN SARFARAZ AMAAN SARFARAZ Follow Jan 13 Building a LinkedIn Outreach Agent with LangGraph and ConnectSafely.ai # langgraph # ai # automation # typescript Comments Add Comment 5 min read Stop Sending Sensitive Data to the Cloud: Build a Local-First Mental Health AI with WebLLM Beck_Moulton Beck_Moulton Beck_Moulton Follow Jan 13 Stop Sending Sensitive Data to the Cloud: Build a Local-First Mental Health AI with WebLLM # privacy # typescript # webgpu # webllm Comments Add Comment 4 min read Transactional AI v0.2: Production-Ready with Full Observability Grafikui Grafikui Grafikui Follow Jan 12 Transactional AI v0.2: Production-Ready with Full Observability # ai # typescript # saga # llm Comments Add Comment 8 min read Building a LinkedIn Outreach Agent with ConnectSafely.ai and Mastra AMAAN SARFARAZ AMAAN SARFARAZ AMAAN SARFARAZ Follow Jan 13 Building a LinkedIn Outreach Agent with ConnectSafely.ai and Mastra # ai # automation # typescript # agents Comments Add Comment 10 min read When to Use a Monorepo Devops Makeit-run Devops Makeit-run Devops Makeit-run Follow Jan 12 When to Use a Monorepo # nx # typescript # devops Comments Add Comment 7 min read Building profiler0x0: An Arcade-Style GitHub Profile Analyzer That Doesn't Judge ackermannQ ackermannQ ackermannQ Follow Jan 12 Building profiler0x0: An Arcade-Style GitHub Profile Analyzer That Doesn't Judge # webdev # github # typescript # node Comments 2 comments 5 min read Introducing Effuse — an experimental reactive framework Chris M. Peréz Chris M. Peréz Chris M. Peréz Follow Jan 12 Introducing Effuse — an experimental reactive framework # webdev # javascript # typescript # programming Comments Add Comment 2 min read I built a WASM execution firewall for AI agents — here’s why Xnfinite Xnfinite Xnfinite Follow Jan 10 I built a WASM execution firewall for AI agents — here’s why # discuss # typescript # rust # ai Comments Add Comment 2 min read Building PDFMitra: A Free PDF Tool with Next.js 14 (Complete Tech Guide) 🚀 Praveen Nayak Praveen Nayak Praveen Nayak Follow Jan 12 Building PDFMitra: A Free PDF Tool with Next.js 14 (Complete Tech Guide) 🚀 # nextjs # typescript # webdev # tutorial Comments Add Comment 3 min read React + TypeScript: The Patterns That Actually Matter Tarun Moorjani Tarun Moorjani Tarun Moorjani Follow Jan 12 React + TypeScript: The Patterns That Actually Matter # typescript # react # programming # javascript 1 reaction Comments Add Comment 8 min read Building a Casio‑Style Scientific Calculator with Vue 3 + TypeScript A0mineTV A0mineTV A0mineTV Follow Jan 12 Building a Casio‑Style Scientific Calculator with Vue 3 + TypeScript # vue # typescript # frontend # javascript Comments Add Comment 3 min read My First Open Source Contribution Was to an Authentication Project — And It Was Surprisingly Friendly Pramod K B Pramod K B Pramod K B Follow Jan 9 My First Open Source Contribution Was to an Authentication Project — And It Was Surprisingly Friendly # opensource # node # typescript # authentication Comments Add Comment 2 min read How to protect server functions with auth middleware in TanStack Start Hiroto Shioi Hiroto Shioi Hiroto Shioi Follow Jan 12 How to protect server functions with auth middleware in TanStack Start # webdev # typescript # fullstack # security 1 reaction Comments Add Comment 3 min read Building Modern Backends with Kaapi: Request validation Part 2 ShyGyver ShyGyver ShyGyver Follow Jan 11 Building Modern Backends with Kaapi: Request validation Part 2 # showdev # typescript # node # opensource Comments Add Comment 3 min read Back to basics: a solid foundation for using AI coding agents in a monorepo Juha Kangas Juha Kangas Juha Kangas Follow Jan 11 Back to basics: a solid foundation for using AI coding agents in a monorepo # tooling # monorepo # ai # typescript Comments Add Comment 2 min read Building a Regulatory-Compliant Accessibility Scanner: From WCAG to Legal Compliance Labontese Labontese Labontese Follow Jan 11 Building a Regulatory-Compliant Accessibility Scanner: From WCAG to Legal Compliance # a11y # typescript # react # webdev Comments Add Comment 6 min read Angular State Management: Signals vs Simple Properties - Which Should I Use? Mohamed Fri Mohamed Fri Mohamed Fri Follow Jan 11 Angular State Management: Signals vs Simple Properties - Which Should I Use? # discuss # performance # typescript # angular Comments Add Comment 1 min read Angular Pipes Explained — From Basics to Custom Pipes (With Real Examples) ROHIT SINGH ROHIT SINGH ROHIT SINGH Follow Jan 11 Angular Pipes Explained — From Basics to Custom Pipes (With Real Examples) # beginners # tutorial # typescript # angular Comments Add Comment 2 min read Brass TS — Building an Effect Runtime in TypeScript (Part 4) Augusto Vivaldelli Augusto Vivaldelli Augusto Vivaldelli Follow Jan 10 Brass TS — Building an Effect Runtime in TypeScript (Part 4) # architecture # opensource # tutorial # typescript Comments Add Comment 3 min read The Mythical One-Fits-All Build Tool Plugin 🦄 (It Actually Exists) Pascal Thormeier Pascal Thormeier Pascal Thormeier Follow Jan 11 The Mythical One-Fits-All Build Tool Plugin 🦄 (It Actually Exists) # typescript # javascript # webdev # programming 4 reactions Comments 3 comments 7 min read loading... trending guides/resources Composition in React: Building like a Senior React Dev 🎉 Black Friday & Cyber Monday 2025: The Best Deals for JavaScript Developers 🚀 Princípios do Clean Code Why Your Vue App Is Reactive Too Much (and How to Fix It) You're Not Building Netflix: Stop Coding Like You Are I Tested 7 Open Source Clerk Alternatives for Full-Stack Developers The Developer's Safety Net - Introduction to TypeScript Angular 21 Developer Guide: AI Tools, Signal Forms, ARIA, and Build Optimizations Building My Own HTTP Server in TypeScript Deno Vs Bun In 2025: Two Modern Approaches To JavaScript Runtime Development Nx vs. Turborepo: Integrated Ecosystem or High-Speed Task Runner? The Key Decision for Your Monorepo Angular 21 is Here: Real Features That Actually Improve Your Daily Workflow How to handle Async Rendering in Vue with Suspense? Triggering Long Jobs in Cloudflare Workers How to Use Path Aliases '@' in React Native with Expo shadcn-glass-ui: Drop-in Glassmorphism for Your shadcn/ui Projects 🎨 Build Your Own Magic Atomic State Code Map: Visualize Code Dependencies with LLM Building a Modern Image Gallery with Next.js 16, TypeScript & Unsplash API Mastering AWS CDK #3 - AWS CDK Development: Best Practices and Workflow 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://docs.suprsend.com/docs/user-preferences#translating-preference-categories-in-user%E2%80%99s-locale	User Preferences - SuprSend, Notification infrastructure for Product teams Skip to main content SuprSend, Notification infrastructure for Product teams home page Search... ⌘ K Community Trust Center Platform Status Postman Collection GETTING STARTED What is SuprSend? Quick Start Guide Best Practices Plan Your Integration Go-live checklist CORE CONCEPTS Templates Users Events Workflow Notification Categories Preferences User Preferences Tenant Preferences Preference Evaluation Tenants Lists Broadcast Objects Translations DLT Guidelines Whatsapp Template Guidelines WORKFLOW BUILDER Design Workflow Node List Workflow Settings Trigger Workflow Validate Trigger Payload Tenant Workflows Notification Inbox Overview Multi Tabs React Javascript (Angular, Vuejs etc) React Native Flutter (Headless) PREFERENCE CENTRE Embedded Preference Centre Javascript Angular React VENDOR INTEGRATION GUIDE Overview Email Integrations SMS Integrations Android Push Whatsapp Integrations iOS Push Chat Integrations Vendor Fallback Tenant Vendor INTEGRATIONS Webhook Connectors MONITORING & DEBUGGING Logs Audit Logs Error Guides MANAGE YOUR ACCOUNT Authentication Methods Contact Us Get Started SuprSend, Notification infrastructure for Product teams home page Search... ⌘ K Ask AI Contact Us Get Started Get Started Search... Navigation Preferences User Preferences Documentation API Reference Management API CLI Reference Developer Resources Changelog Documentation API Reference Management API CLI Reference Developer Resources Changelog Preferences User Preferences OpenAI Open in ChatGPT Learn how user preferences work in SuprSend and how to capture them. OpenAI Open in ChatGPT Before you start: Make sure you’ve set up notification categories first. See Manage Categories and Preferences for step-by-step instructions. Preferences let users control which notifications they receive. Instead of an all-or-nothing approach, users can opt out of specific categories, choose preferred channels, and set notification frequency. This granular control reduces the chance that users disable all notifications from your platform. In SuprSend, you can use ready-made UI and APIs to manage multi-tenant preference use cases. This includes letting admins set preferences for internal teams and handle notifications for enterprise customers, where companies, customers, and end users have distinct preferences. How It Works Preferences are evaluated in priority order: User Preference → Tenant Default → Category Default Three Levels of Control Global channel opt-outs, category preferences, and channel opt-outs within categories What are user preferences? Preferences only work with sub-categories: User preferences apply to sub-categories you create, not root-categories (System, Transactional, Promotional). Use sub-category slugs in workflows for preferences to work. Each user has a preference set that controls which notifications they receive. A preference set has three levels of control: channel_preferences — Global channel opt-outs (e.g., opt out of all email) categories — Category-level preferences (opt in/out of all channels of a notification type) opt_out_channels — Opt-in/out of specific channels within a category Example: Copy Ask AI { "channel_preferences" : [ { "channel" : "email" , "is_restricted" : true } ], "categories" : [ { "category" : "invoice-ready" , "preference" : "opt_out" }, { "category" : "payment-reminder" , "preference" : "opt_in" , "opt_out_channels" : [ "slack" ] } ] } In this example: user opted out of email globally, opted out of invoice-ready category completely, and stays opted in to payment-reminder but without Slack. How preferences are determined When a user hasn’t set their own preferences in a category, SuprSend uses defaults in this order: User Preference — Individual user’s explicit choices (highest priority) Tenant Default Preference — Default preferences set by tenant for the category Category Default Preference — Default preferences set at the category level (lowest priority) Preference precedence: User Preference → Tenant Default Preference → Category Default Preference Preference precedence is determined at category level . So, if a user overrides preference for a category but doesn’t touch other categories, defaults continue to apply to the untouched categories. Setting up preference categories Before users can set their preferences, you must first create and configure preference categories. For step-by-step setup instructions, see Manage Categories and Preferences . Default preferences Default preferences determine how users receive notifications when they haven’t set their own preferences. Configure these at the sub-category level when setting up categories. What default preferences control Default preferences control: Channel or Category defaults : Which categories or channels will be turned on/off by default on users’ preference page. Mandatory channels : Which channel or category users cannot opt out of (shown as disabled on preference page) Visibility : Whether a category appears on the preference page Preference types On — Users receive this category's notifications by default Users will receive notifications in this category by default. You can configure Opt-in Channels to specify which channels are included in the default “On” state: All : All available channels are enabled by default Selected Channels only : Only specific channels you select are enabled by default (e.g., Email, Android Push, iOS Push, In-App Inbox, MS Teams, Slack) Off — Users must opt in to get notifications Users will not receive notifications unless they change the preference. Can't Unsubscribe — Users cannot opt out of mandatory channels in this category Prevents users from fully opting out of the category. When selected, you can configure: Mandatory Channels : Channels which can’t be opted out of by the user. Set to “All” or “Selected Channels”. Opt-in Channels : In case of “Selected” Mandatory Channels, you can configure the channels that will be opted in by default. Channels other than mandatory and opt-in will be skipped for sending notification unless user explicitly opts in to them. Even when a category is set to “Can’t Unsubscribe,” users can still control channel-level preferences if your channel-level settings allow it. This configuration gives you fine-grained control over which channels a user is opted into by default, letting you differentiate between must-deliver channels, default-on channels, and optional channels. Capturing user preferences Users can set their preferences through one of the following methods: Hosted preference page Once you publish preference categories, SuprSend automatically generates a dedicated unsubscription webpage for collecting user preferences . Users can set channel-specific preferences from the hosted page. If the link is included in an email, the hosted page will show and save email preferences. Include it in your templates using {{$hosted_preference_url}} . This page is currently hosted on a SuprSend domain, but you can reach out to [email protected] if you’d prefer it hosted on your own domain. Embed in your product You can embed the preference interface directly inside your product using SuprSend’s ready-made UI components. SDKs exist in the languages below. Update your product preference page link on the tenant page and render it in templates using {{$embedded_preference_url}} . Javascript React Angular Embeddable preference page Controlling what categories to show on UI It’s always a good practice to show only the categories that are relevant to the user. There are two ways to achieve this: Hide categories for tenant users In a multi-tenant setup, tenants or admins can control which categories their users see. Setting visible_to_subscriber: false in tenant preferences hides the category from tenant users’ preference pages. Hidden categories won’t send notifications to those users, even if they previously opted in. Filter categories with tags Use tags to show categories based on user roles, departments, or teams. Filter categories in the preference center using the tags query parameter. 1 Setting Preference tags Tags can be added to sections and sub-categories directly from Developers → Notification Categories in the SuprSend Console. When a tag is assigned at the section level, it automatically applies to all categories under that section—so filtering by a section tag also filters its child categories. 2 Filter Categories with Tags You can filter categories using the tags query parameter in the API. This can be a simple tag match (e.g. tags=tag1 ) or a more advanced filter using logical operators. Supported operators: Operator Operand Datatype Description Example exists boolean Returns categories where any tag is set tags={ "exists": true } not string Excludes categories that have the specified tag tags={ "not": "admin" } or array Returns categories that match any of the provided tags tags={ "or": ["sales", "marketing"] } and array Returns categories that match all provided tags tags={ "and": ["sales", "manager"] } You can combine these operators for nested filtering like tags={ "or": [{ "and": ["sales", "manager"] }, { "and": ["marketing", "associate"] }] } . If no tags are provided, the preference center returns all visible categories. For details on how tags work, see Tags . Translating preference categories in user’s locale Upload translation files for your category names and descriptions. See How to manage Category translations for details. Once uploaded, pass a locale parameter (e.g., es , fr , de ) when: Loading the embeddable preference center As a query parameter in the get user preference API . The hosted preference page picks the locale from user’s profile. On hosted preference page, Dynamic content (category names, descriptions) is translated using translation files you upload. Static content (CTA text, labels, buttons, etc.) is translated automatically using SuprSend’s built-in i18n support for commonly used languages. You can see the list of supported languages below. Supported languages Language Code English en Spanish es French fr German de Italian it Portuguese pt Catalan ca Russian ru Dutch nl Polish pl Japanese ja Vietnamese vi Language Code Indonesian id Korean ko Serbian sr Norwegian no Hebrew he Chinese zh Finnish fi Swedish sv Czech cs Lithuanian lt Arabic ar How preferences are evaluated SuprSend evaluates user preferences at send time. For every recipient, the system checks user-level preferences first, then tenant-level overrides, and finally category defaults. For detailed information on the evaluation process, see Preference Evaluation . Other ways to unsubcribe from notifications In addition to the preference center within SuprSend, communication channels provide their own opt-out options, which SuprSend manages internally. Email: Unsubscribe URL header Gmail requires an unsubscribe URL in email headers when sending bulk emails (5,000+ emails/day). Most email providers expect you to add your own unsubscription page or offer a basic all-or-nothing opt-out option. You can add {{$hosted_preference_url}} here to load the SuprSend hosted preference page from the email header. Inbox (In-App): Render preference page inside your Inbox Companies also give users the option to load preference settings inside their in-app Inbox or provide a link to redirect users to the Preference center in their product. Mobile Push: Preference Page in App settings For mobile push notifications, users typically manage their preferences through the app settings. The category you assign in your workflow is also sent as the push “category” (used by Android/iOS to group notifications). If you set preference categories, the system automatically reflects them in the user’s app settings, loading similar preference controls. SMS & Whatsapp: Reply `STOP` Users generally unsubscribe from Short Message Service (SMS) by replying “STOP.” SuprSend automatically marks the SMS channel as inactive in the user’s profile when it receives a STOP reply. For WhatsApp, opt-out behavior depends on the provider; where supported, users can reply STOP and SuprSend will mark the channel inactive. FAQ How do I set up a digest schedule? You can create sub-categories for different digest schedules or set the digest schedule in the user profile and pass a dynamic schedule in the workflow digest node. An option to set the digest schedule directly on your preference page will be available soon. I have a use case where a company has multiple departments/roles, and the admin will set preferences for users in these departments. You can manage this with tenant preferences. In the SuprSend system, each tenant represents an organization, and the administrator sets which categories to send to their internal team using the tenant preference API . What happens to existing user preference view if I change default preference setting? Changing the default preference for a category doesn’t affect users who have already made changes to that category. For categories where users haven’t made any changes, the preferences update according to the new default settings. I have multiple enterprise customers with various product offerings. Customers should only receive notifications for the products they have enabled, and the same should be visible on their preference page. How can I manage this in SuprSend? You can turn off categories for tenants from the tenant page on the SuprSend console. Turning off the preference for a category automatically removes it from the tenant preference APIs and UI view. To further apply this to the tenant’s users, set visible to subscriber to false in the default tenant preferences to hide the category from the tenant’s end users. Why don't I see the 'inbox' channel in my user preferences? The inbox channel preference is behind a feature flag and needs to be enabled for your account. If you don’t see the inbox channel in your user preferences, contact [email protected] to have the feature flag enabled for your workspace. Why do users still receive promotional notifications even after unsubscribing from all categories? Unsubscribing from top-level categories (System, Transactional, Promotional) is not supported . Preferences only work with sub-categories you create. If you’re sending notifications using a top-level category like "promotional" in your workflows, users cannot unsubscribe from those notifications through the preference center, even if they unsubscribe from all visible categories. Solution: Create sub-categories under the Promotional category (e.g., “Marketing”, “Newsletter”, “Product Updates”) and use those sub-category slugs in your workflows instead of the top-level category. This allows users to: See and control preferences for each notification type Opt out of specific sub-categories Have their preferences respected when you send notifications Best practice: Organize notifications into meaningful sub-categories rather than using top-level categories directly. This provides users with granular control and improves their experience. Can I use user preferences in workflow branching to control which notifications are sent? User preferences are not passed in the workflow payload, so you cannot directly access them in branch conditions or other workflow nodes. Workaround: If you need to use preference-based logic in workflows (e.g., to route notifications based on user preferences or combine multiple notification scenarios in a single workflow), you can: Store the same preference data as custom properties in the user profile Use those custom properties in branch conditions to route notifications Example use case: If you want to combine multiple notification scenarios (e.g., “New Comment”, “Reply on my comment”, “I am mentioned”) in a single workflow to avoid duplicate notifications, you can: Store user preferences for each scenario as custom properties (e.g., wants_new_comment_notifications: true , wants_mention_notifications: true ) Use branch conditions to check these properties and route notifications accordingly This allows you to have one workflow that handles all scenarios while respecting user preferences Alternative approach: Create separate workflows for each notification scenario with conditions in the Trigger node. Each workflow can use its own preference category, allowing users to control each scenario independently. How do I let users control both notification on/off and the time they want to be reminded (e.g., medicine reminders)? You can combine preference categories with dynamic digest schedules to achieve this: 1. Set up preference categories: Create a preference category (e.g., “medicine-reminders”) that users can opt in/out of using the preference APIs or preference center UI . 2. Store time preference as user property: When users select their preferred reminder time, store it as a custom property in their user profile. For example: Copy Ask AI user.set({ "medicineReminderTime" : { "frequency" : "daily" , "time" : "09:00" , "tz_selection" : "recipient" } }) 3. Use dynamic schedule in digest node: In your workflow’s digest node, configure it to use a dynamic schedule that references the user property (e.g., ."$recipient".medicineReminderTime ). The digest will only send if the user has opted in to the category, and it will send at their preferred time. Implementation flow: Client side (React Native) : Capture user’s time preference and call your backend API Server side (Supabase Edge Function) : Update both the user’s preference (opt in/out) via SuprSend preference API and store the time preference as a user property Workflow : Use preference category to control on/off, and dynamic schedule to control timing For detailed information, see Dynamic Schedule in the digest documentation. Related documentation Notification Categories - Setting up categories & defaults Manage Categories and Preferences - Complete guide to setting up and managing categories and preferences Tenant Preferences - Managing tenant-level preferences Preference Evaluation - How SuprSend evaluates preferences at runtime Was this page helpful? Yes No Suggest edits Raise issue Previous Tenant Preferences Learn how to manage preferences for your tenants and their users. Next ⌘ I x github linkedin youtube Powered by On this page What are user preferences? How preferences are determined Setting up preference categories Default preferences What default preferences control Preference types Capturing user preferences Hosted preference page Embed in your product Controlling what categories to show on UI Hide categories for tenant users Filter categories with tags Translating preference categories in user’s locale How preferences are evaluated Other ways to unsubcribe from notifications FAQ Related documentation	2026-01-13T08:49:46
https://pt-br.facebook.com/login/?next=https%3A%2F%2Fwww.facebook.com%2Fshare_channel%2F%3Ftype%3Dreshare%26link%3Dhttps%253A%252F%252Fdev.to%252Ftatyanabayramova%252Fglaucoma-awareness-month-363o%26app_id%3D966242223397117%26source_surface%3Dexternal_reshare%26display%26hashtag	Entrar no Facebook Notice Você deve se conectar para continuar. Entrar no Facebook Você deve se conectar para continuar. Entrar Esqueceu a conta? · Cadastre-se no Facebook Português (Brasil) 한국어 English (US) Tiếng Việt Bahasa Indonesia ภาษาไทย Español 中文(简体) 日本語 Français (France) Deutsch Cadastre-se Entrar Messenger Facebook Lite Vídeo Meta Pay Meta Store Meta Quest Ray-Ban Meta Meta AI Mais conteúdo da Meta AI Instagram Threads Central de Informações de Votação Política de Privacidade Central de Privacidade Sobre Criar anúncio Criar Página Desenvolvedores Carreiras Cookies Escolhas para anúncios Termos Ajuda Upload de contatos e não usuários Configurações Registro de atividades Meta © 2026	2026-01-13T08:49:46
https://dev.to/aws-builders/define-methods-of-deploying-and-operating-in-the-awscloud-56dh	Define Methods of Deploying and Operating in the AWS Cloud - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Ntombizakhona Mabaso for AWS Community Builders Posted on Jan 3           Define Methods of Deploying and Operating in the AWS Cloud # aws # cloud # cloudcomputing # cloudpractitioner Exam Guide: Cloud Practitioner (22 Part Series) 1 Cloud Practitioner Exam Guide 2 Define the Benefits of the AWS Cloud ... 18 more parts... 3 Identify Design Principles of the AWS Cloud 4 Understand the Benefits of and Strategies for Migration to the AWS Cloud 5 Understand Concepts of Cloud Economics 6 Understand the AWS Shared Responsibility Model 7 Understand AWS Cloud Security, Governance, and Compliance Concepts 8 Identify AWS Access Management Capabilities 9 Identify Components and Resources for Security 10 Define Methods of Deploying and Operating in the AWS Cloud 11 Define the AWS Global Infrastructure 12 Identify AWS Compute Services 13 Identify AWS Database Services 14 Identify AWS Network Services 15 Identify AWS Storage Services 16 Identify AWS Artificial Intelligence and Machine Learning (AI/ML) Services And Analytics Services 17 Identify Services From Other In-Scope AWS Service Categories 18 Compare AWS Pricing Models 19 Understand Resources For Billing, Budget, and Cost Management 20 Identify AWS Technical Resources And AWS Support Options 21 Technologies and Concepts: Cloud Practitioner (CLF-C02) 22 My Cloud Practitioner Certification Journey and the Resources to Certify with Confidence 🧰 Exam Guide: Cloud Practitioner Domain 3: Cloud Technology & Services 📘 Task Statement 3.1 Another Day, Another Domain If you’ve ever thought “I’ll just click around in the console real quick,” and suddenly it’s 2 hours later and nothing is documented or deployed, well congrats, you’ve discovered why this domain exists. This task is about knowing how to deploy and operate on AWS using the right method for the job. 🎯What Is This Task Testing? You must understand: Ways of provisioning and operating in AWS Ways to access AWS services Cloud deployment models (cloud, hybrid, on-premises) How to choose between: AWS Management Console Programmatic access (APIs, SDKs, CLI) Infrastructure as Code (IaC) 1) 🔑 Ways to Access AWS Services AWS services can be accessed in multiple ways. AWS Management Console The Graphical User Interface (GUI) A web-based interface used for interactive management. The AWS Management Console is Best For: learning AWS services quick checks and ad-hoc changes visually exploring resources and settings Manual steps are harder to repeat consistently if you use the console, that's where programmatic access comes in. Programmatic Access APIs, SDKs, CLI Programmatic access means managing AWS through commands or code. AWS APIs All actions in AWS are ultimately API calls. APIs Are Best For: automation and integrating AWS actions into applications and pipelines. AWS SDKs Language-specific libraries (e.g., Python, Java, JavaScript) that call AWS APIs. SDKs Are Best For: building apps that directly interact with AWS services. AWS CLI Command-line tool to call AWS services. The CLI Is Best For: scripting repetitive tasks automation from a terminal faster operations than clicking through the console 2) 🧱 Infrastructure as Code (IaC) IaC means defining infrastructure such as networks, servers, permissions, etc. using templates or code instead of a manual setup like the console. Why IAC Matters: repeatable deployments consistent environments (dev/test/prod) version control and change tracking reduced configuration drift and human error 3) 🔁 One-Time Operations vs Repeatable Processes Deciding whether a task should be manual or automated? One-time operations Examples: a single quick change, a one-off test, initial learning. AWS Management Console (or a simple CLI command). Repeatable processes Examples: launching the same environment for every project, scaling standardized deployments, enforcing consistent configuration. IaC and automation (templates + pipelines, CLI scripts, SDK-based tooling). If you’ll do it more than once, or if consistency matters, lean toward automation/IaC . 4) 🌍 Cloud Deployment Models You must be able to identify common deployment models. Cloud Public Cloud All workloads run in the cloud (e.g., AWS), with minimal/no on-prem infrastructure. Why Organizations Choose The Cloud: simplicity, scalability, reduced data center management. Hybrid Cloud + On-Premises Some systems run in AWS, others remain on-premises—connected via networking and identity integrations. Why Organizations Choose Hybrid Cloud: regulatory or data residency constraints legacy systems that can’t move yet phased migration strategy “keep some workloads in our data center but extend to AWS,” that’s hybrid . Private Cloud On Premises Workloads run in a company’s own data center. How to Choose the Right Deployment Method Do you need speed + simplicity right now? → Console Do you need automation or integration with software? → API/SDK Do you need scripting and repeatable commands? → CLI Do you need consistent, repeatable environments with version control? → IaC ✅ Quick Exam-Style Summary AWS access methods: Console , CLI , SDK , APIs , and IaC . Prefer IaC/automation for repeatable, standardized deployments. Choose deployment models: Cloud : everything in AWS Hybrid : mix of AWS + on-prem On-premises : everything in a private data center Additional Resources Accessing AWS services Types of cloud computing Exam Guide: Cloud Practitioner (22 Part Series) 1 Cloud Practitioner Exam Guide 2 Define the Benefits of the AWS Cloud ... 18 more parts... 3 Identify Design Principles of the AWS Cloud 4 Understand the Benefits of and Strategies for Migration to the AWS Cloud 5 Understand Concepts of Cloud Economics 6 Understand the AWS Shared Responsibility Model 7 Understand AWS Cloud Security, Governance, and Compliance Concepts 8 Identify AWS Access Management Capabilities 9 Identify Components and Resources for Security 10 Define Methods of Deploying and Operating in the AWS Cloud 11 Define the AWS Global Infrastructure 12 Identify AWS Compute Services 13 Identify AWS Database Services 14 Identify AWS Network Services 15 Identify AWS Storage Services 16 Identify AWS Artificial Intelligence and Machine Learning (AI/ML) Services And Analytics Services 17 Identify Services From Other In-Scope AWS Service Categories 18 Compare AWS Pricing Models 19 Understand Resources For Billing, Budget, and Cost Management 20 Identify AWS Technical Resources And AWS Support Options 21 Technologies and Concepts: Cloud Practitioner (CLF-C02) 22 My Cloud Practitioner Certification Journey and the Resources to Certify with Confidence Top comments (0) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse AWS Community Builders Follow Build On! Would you like to become an AWS Community Builder? Learn more about the program and apply to join when applications are open next. Learn more More from AWS Community Builders 🩺 How I Troubleshoot an EC2 Instance in the Real World (Using Instance Diagnostics) # aws # ec2 # linux # cloud Explain Basic AI Concepts And Terminologies # aws # ai # aipractitioner # cloud What I Learned Using Specification-Driven Development with Kiro # aws # serverless # kiro 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV Forem — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . Forem © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://code.tutsplus.com/c/python/t/courses	Python Courses in Code \| Envato Tuts+ Unsupported browser This site was designed for modern browsers and tested with Internet Explorer version 10 and later. It may not look or work correctly on your browser. Skip to content Envato: Get every type of asset for any type of project, and a full stack of AI tools From $16.50/m global-search#onSuggestionContainerMousedown" > Design Business Photo Video Web Design Code Code View all Code Start Learning WordPress WordPress View all WordPress Plugin Development Theme Development HTML/CSS HTML/CSS View all HTML/CSS HTML CSS JavaScript for Designers Bootstrap Animation HTML Templates Landing Pages SVG Mobile Development Mobile Development View all Mobile Development iOS Development iOS Templates Android Development Android Templates React Native Development React Native Templates Ionic Development Ionic Templates Corona Firebase Kotlin JavaScript JavaScript View all JavaScript React Vue.js Node jQuery Angular Web APIs PHP PHP View all PHP Laravel PHP Scripts CodeIgniter Yii Coding Fundamentals Coding Fundamentals View all Coding Fundamentals OOP Functional Programming Databases & SQL Security Testing Workflow Design Patterns Rest API Machine Learning Authentication Version Control & Git Performance XML AJAX Regular Expressions Tools Terminal and CLI Python Python View all Python Django Ruby Ruby View all Ruby Ruby on Rails Game Development Cloud & Hosting Cloud & Hosting View all Cloud & Hosting AWS Web Servers Hosting Scaling Databases & SQL Music Sign In Tuts+ YouTube Envato Get unlimited creative assets Go to Envato \| Tuts+ YouTube \| Sign In global-nav#sendNewNavDataLayerEvent focusin->subcategories-nav#hideAllSubCategoriesMenuWrappers'> Design global-nav#sendNewNavDataLayerEvent focusin->subcategories-nav#hideAllSubCategoriesMenuWrappers'> Business global-nav#sendNewNavDataLayerEvent focusin->subcategories-nav#hideAllSubCategoriesMenuWrappers'> Photo global-nav#sendNewNavDataLayerEvent focusin->subcategories-nav#hideAllSubCategoriesMenuWrappers'> Video global-nav#sendNewNavDataLayerEvent focusin->subcategories-nav#hideAllSubCategoriesMenuWrappers'> Web Design global-nav#sendNewNavDataLayerEvent focusin->subcategories-nav#hideAllSubCategoriesMenuWrappers'> Code subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='WordPress'> WordPress Start Learning Plugin Development Theme Development All WordPress subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='HTML/CSS'> HTML/CSS Start Learning HTML CSS JavaScript for Designers Bootstrap Animation HTML Templates Landing Pages SVG All HTML/CSS subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='Mobile Development'> Mobile Development Start Learning iOS Development iOS Templates Android Development Android Templates React Native Development React Native Templates Ionic Development Ionic Templates Corona   Firebase Kotlin All Mobile Development subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='JavaScript'> JavaScript Start Learning React Vue.js Node jQuery Angular Web APIs All JavaScript subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='PHP'> PHP Start Learning Laravel PHP Scripts CodeIgniter Yii All PHP subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='Coding Fundamentals'> Coding Fundamentals Start Learning OOP Functional Programming Databases & SQL Security Testing Workflow Design Patterns Rest API Machine Learning   Authentication Version Control & Git Performance XML AJAX Regular Expressions Tools Terminal and CLI All Coding Fundamentals subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='Python'> Python Start Learning Django All Python subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='Ruby'> Ruby Start Learning Ruby on Rails All Ruby subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='Game Development'> Game Development subcategories-nav#show mouseleave->subcategories-nav#hide click->subcategories-nav#show' test-nav-item-name='Cloud & Hosting'> Cloud & Hosting Start Learning AWS Web Servers Hosting Scaling Databases & SQL All Cloud & Hosting global-nav#sendNewNavDataLayerEvent focusin->subcategories-nav#hideAllSubCategoriesMenuWrappers'> Music global-search#onSuggestionContainerMousedown" > Get unlimited creative assets Learn Python Master the Python programming language! Learn how to use Python for data analysis and automation, and discover useful frameworks like Django. Read more Read less All content Courses Tutorials All Python courses: Filters content-filters-small-screen-component#toggleContentFiltersDialog'> Filters Filters content-filters-small-screen-component#toggleContentFiltersDialog'> turbo-frame>div:first-child]:mt-0'> content-filters-small-screen-component#clearFilters'>Clear Filters content-filters-small-screen-component#showResults'>Show Results ]:mb-10 md:[&>]:mb-16 [&>*]:mr-6 content-results__with-filters" data-controller='category-sidebar-ad-mobile' data-analytics-context="content results" > Django Getting Started With Django Course • Beginner If you like the elegance of the Python programming language, Django is the web framework for you! Django is a powerful but pragmatic framework, with an... Derek Jensen • 23 Aug 2019 Python Connect a Database to Your Python Application Course • Intermediate Most apps will need a database for the back-end, but the specific database you choose shouldn't make much of a difference to your app's architecture. With... Derek Jensen • 21 May 2018 Python Learn to Code With Python Course • Beginner Python is a powerful language that is easy to learn and excels at many different types of computing. It is used to run large, well-known websites. It is used... Derek Jensen • 9 Mar 2017 Django Create a REST API With Django Course • Intermediate Python has long been known as a user-friendly language for learning software development. But just because it is easy to learn doesn’t mean that it isn’t... Derek Jensen • 11 Jan 2017 Python Data Handling With Python Course • Beginner Python is a powerful language that is easy to learn and excels at many different types of computing. It is used to run large, well-known websites. It is used... Derek Jensen • 18 Jul 2016 Django Build a News Aggregator With Django Course • Beginner If you like the elegance of the Python programming language, Django is the web framework for you! Django is a powerful but pragmatic framework, with an... Derek Jensen • 5 Feb 2016 Python Crawl the Web With Python Course • Beginner In a recent business venture, I found it necessary to collect bulk data from different online sources in order to centralize it and make it easier for people... Derek Jensen • 2 Jul 2015 Python Getting Started with Python Course • Beginner In this course, you’ll learn how to use the Python programming language. We’ll begin with the very basics, and then move our way up to creating dynamic... Jesse Shawl • 21 Aug 2012 Related Categories JavaScript WordPress Mobile Development PHP JavaScript WordPress Mobile Development PHP Laravel Android Development React Angular Ready to make your best work? Get tutorials, tips and tricks straight to your inbox. Sign up Unsubscribe at any time. Privacy Policy. ga-analytics#sendElementsClickEvent" > One subscription. Unlimited downloads of assets. Full stack of AI tools. Find everything from photos to fonts, and templates to so much more. Start creating Unlimited Downloads From $16.50/month Get access to over one million creative assets on Envato. Over 9 Million Digital Assets Everything you need for your next creative project. Create Beautiful Logos, Designs & Mockups in Seconds Design like a professional without Photoshop. Join the Community Share ideas. Host meetups. Lead discussions. Collaborate. Discover About Envato Our Pricing & Plans Stock Video Video Templates Royalty-Free Music Stock Photos Fonts Popular Searches License & User Terms License Terms Terms & Conditions Privacy Policy Acceptable Use Policy Fair Use Policy Cookies Cookie Settings Do not sell or share my personal information Resources Discover Tuts+ Video & Music Design Marketing Web Design Explore Blog Help Help Center Become an Affiliate About Us Who We Are Our Products Our Purpose Join Our Team Company Blog Authors Become an Author Author Sign In Author Help Center Envato Market Envato Tuts+ Placeit by Envato Mixkit All Products Sitemap © 2025 Envato Trademarks and brands are the property of their respective owners.	2026-01-13T08:49:46
https://dev.to/alexanderhodes/xcode-cloud-build-fails-due-command-exited-with-non-zero-exit-code-70-6aj#solving-the-signing-issue	XCode Cloud Build fails due Command exited with non-zero exit-code: 70 - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Alexander Hodes Posted on Jan 12 XCode Cloud Build fails due Command exited with non-zero exit-code: 70 # appdev # ios # cicd Back from vacation and some days after the new year started our build pipeline for the iOS app in Xcode Cloud fails. The xcodebuild command still succedded but the signing of the app for ad-hoc and app-store distribution failed with Command exited with non-zero exit-code: 70 That's a snippet from the log. Run command: 'xcodebuild -exportArchive -archivePath /Volumes/workspace/tmp/3dbe9cdf-8b26-4d08-98fc-ec820978e845.xcarchive -exportPath /Volumes/workspace/adhocexport -exportOptionsPlist /Volumes/workspace/ci/ad-hoc-exportoptions.plist '-DVTPortalRequest.Endpoint=http://172.16.47.196:8089' -DVTProvisioningIsManaged=YES -IDEDistributionLogDirectory=/Volumes/workspace/tmp/ad-hoc-export-archive-logs -DVTSkipCertificateValidityCheck=YES -DVTServicesLogLevel=3' Error Command exited with non-zero exit-code: 70 Enter fullscreen mode Exit fullscreen mode Some background why we use Xcode cloud. At the beginning of last year, we've migrated from Azure Devops to Xcode Cloud because the build of the iOS version of our React Native app took about one hour. For internal testing we push the distribute the app by Firebase App Distribution . The migration was pretty easy using some additional steps in the iOS build process with the custom build scripts . With using XCode cloud the build time decreased by more than 50%. Investigating it further During the vacation days nothing has changed. Our workflow was still the same and there weren't any code changes which could lead to the problem. Therefore the only reason could be expired certificates or provisioning profiles. Unfortunately, there were no certificates expired or revoked. One important artifact of every build in XCode cloud is the Log file which contains the logs of the xcodebuild and signing steps. After comparing the logs for signing from the failed with the last successful one something weird was visible. The request for requesting the DVTServices: Response payload didn't contain any certificates. 2026-01-12T12:23:16.992744779Z 2025-12-23 06:56:24.555 xcodebuild[26013:105669] DVTServices: Response payload: { 2026-01-12T12:23:16.992747015Z "data" : [] 2026-01-12T12:23:16.992808870Z "links" : { 2026-01-12T12:23:16.992811619Z "self" : "https://developer-ci.corp.apple.com:443/services/v1/certificates?filter%5BcertificateType%5D=DISTRIBUTION_MANAGED&limit=200" 2026-01-12T12:23:16.992814240Z }, 2026-01-12T12:23:16.992816002Z "meta" : { 2026-01-12T12:23:16.992817707Z "paging" : { 2026-01-12T12:23:16.992819465Z "total" : 1, 2026-01-12T12:23:16.992821323Z "limit" : 200 2026-01-12T12:23:16.992823022Z } 2026-01-12T12:23:16.992824692Z } 2026-01-12T12:23:16.992826793Z } Enter fullscreen mode Exit fullscreen mode In the last successful run, there was one included. 2025-12-23T14:56:24.992744779Z 2025-12-23 06:56:24.555 xcodebuild[26013:105669] DVTServices: Response payload: { 2025-12-23T14:56:24.992747015Z "data" : [ { 2025-12-23T14:56:24.992749303Z "type" : "certificates", 2025-12-23T14:56:24.992751380Z "id" : "id", 2025-12-23T14:56:24.992753249Z "attributes" : { 2025-12-23T14:56:24.992755418Z "serialNumber" : "abc", 2025-12-23T14:56:24.992773108Z "certificateContent" : "", 2025-12-23T14:56:24.992784914Z "displayName" : "Company Name", 2025-12-23T14:56:24.992787108Z "name" : "Apple Distribution: Company Name", 2025-12-23T14:56:24.992789263Z "platform" : null, 2025-12-23T14:56:24.992791524Z "responseId" : "136ed97e-949c-428b-b0a3-c5513e2cfacc", 2025-12-23T14:56:24.992793996Z "expirationDate" : "2026-04-07T08:06:15.000+00:00", 2025-12-23T14:56:24.992796344Z "certificateType" : "DISTRIBUTION_MANAGED" 2025-12-23T14:56:24.992798263Z }, 2025-12-23T14:56:24.992800337Z "links" : { 2025-12-23T14:56:24.992802983Z "self" : "https://developer-ci.corp.apple.com:443/services/v1/certificates/abc" 2025-12-23T14:56:24.992805363Z } 2025-12-23T14:56:24.992807115Z } ], 2025-12-23T14:56:24.992808870Z "links" : { 2025-12-23T14:56:24.992811619Z "self" : "https://developer-ci.corp.apple.com:443/services/v1/certificates?filter%5BcertificateType%5D=DISTRIBUTION_MANAGED&limit=200" 2025-12-23T14:56:24.992814240Z }, 2025-12-23T14:56:24.992816002Z "meta" : { 2025-12-23T14:56:24.992817707Z "paging" : { 2025-12-23T14:56:24.992819465Z "total" : 1, 2025-12-23T14:56:24.992821323Z "limit" : 200 2025-12-23T14:56:24.992823022Z } 2025-12-23T14:56:24.992824692Z } 2025-12-23T14:56:24.992826793Z } Enter fullscreen mode Exit fullscreen mode Solving the signing issue Solving this issue is much simpler than expected. In the Apple Developer Portal you need to open the Certificates, Identifiers & Profiles section. There some certificates created by Xcode Cloud will appear. These certificates are created automatically by Xcode Cloud when starting a workflow. You just need to revoke those certificates by clicking on revoke in the detail view of the certificate. After the deletion of these certificates, you can trigger your workflows again. The signing for ad-hoc and app-store distribution should work and new certificates should be generated. The reason for this issue might be that Apple internally generates some private keys which will expire or will be deleted due to the end of the year. Top comments (0) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse Alexander Hodes Follow Location Fulda, Germany Work Fullstack Developer Joined Jan 24, 2021 Trending on DEV Community Hot How to Crack Any Software Developer Interview in 2026 (Updated for AI & Modern Hiring) # softwareengineering # programming # career # interview What was your win this week??? # weeklyretro # discuss I Didn’t “Become” a Senior Developer. I Accumulated Damage. # programming # ai # career # discuss 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fdev.to%2Fsunny7899%2Fdocumenting-the-journey-preparing-for-a-senior-ui-engineer-role-at-servicenow-81a&title=Documenting%20the%20Journey%3A%20Preparing%20for%20a%20Senior%20UI%20Engineer%20Role%20at%20ServiceNow&summary=There%E2%80%99s%20a%20moment%20in%20every%20engineering%20career%20where%20you%20pause%E2%80%94not%20because%20you%E2%80%99re%20stuck%2C%20but...&source=DEV%20Community	LinkedIn Login, Sign in \| LinkedIn Sign in Sign in with Apple Sign in with a passkey By clicking Continue, you agree to LinkedIn’s User Agreement , Privacy Policy , and Cookie Policy . or Email or phone Password Show Forgot password? Keep me logged in Sign in We’ve emailed a one-time link to your primary email address Click on the link to sign in instantly to your LinkedIn account. If you don’t see the email in your inbox, check your spam folder. Resend email Back New to LinkedIn? Join now Agree & Join LinkedIn By clicking Continue, you agree to LinkedIn’s User Agreement , Privacy Policy , and Cookie Policy . LinkedIn © 2026 User Agreement Privacy Policy Community Guidelines Cookie Policy Copyright Policy Send Feedback Language العربية (Arabic) বাংলা (Bangla) Čeština (Czech) Dansk (Danish) Deutsch (German) Ελληνικά (Greek) English (English) Español (Spanish) فارسی (Persian) Suomi (Finnish) Français (French) हिंदी (Hindi) Magyar (Hungarian) Bahasa Indonesia (Indonesian) Italiano (Italian) עברית (Hebrew) 日本語 (Japanese) 한국어 (Korean) मराठी (Marathi) Bahasa Malaysia (Malay) Nederlands (Dutch) Norsk (Norwegian) ਪੰਜਾਬੀ (Punjabi) Polski (Polish) Português (Portuguese) Română (Romanian) Русский (Russian) Svenska (Swedish) తెలుగు (Telugu) ภาษาไทย (Thai) Tagalog (Tagalog) Türkçe (Turkish) Українська (Ukrainian) Tiếng Việt (Vietnamese) 简体中文 (Chinese (Simplified)) 正體中文 (Chinese (Traditional))	2026-01-13T08:49:46
https://zeroday.forem.com/amit_ambekar_c022e6732f8d/december-email-security-your-strongest-defense-against-everyday-cyber-threats-1caj#comments	✉️ December: Email Security — Your Strongest Defense Against Everyday Cyber Threats ✉️ - Security Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account Security Forem Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Amit Ambekar Posted on Dec 2, 2025           ✉️ December: Email Security — Your Strongest Defense Against Everyday Cyber Threats ✉️ # email # cybersecurity # education # soc Email remains the No.1 attack vector for cybercriminals. From phishing and malware to invoice fraud, most attacks begin with a single deceptive email and SMBs are the easiest targets because attackers assume they have fewer protections. As the year closes and holidays approach, phishing spikes sharply. December becomes the busiest month for fake login alerts, parcel-delivery scams and urgent payment requests. This month’s focus: strengthening email security for every employee and every device. 🎯 Why Email Security Matters 🎯 Even well-trained users can get tricked by realistic phishing emails. Real-world breach data shows: Over 90% of attacks start with a phishing email. Find that 6× more email fraud attempts during the holiday season. Attackers now use AI-generated emails that look 100% legitimate. That's why December is the perfect month to reinforce email hygiene and boost awareness. 🧩 Core Email Security Practices 🧩 Implementing a few simple, practical controls can significantly reduce risk: 1️⃣ Enable SPF, DKIM & DMARC (Essential Email Authentication) These three protocols verify whether emails are genuinely from your domain and prevent attackers from spoofing your address. SPF – verifies allowed sender IPs DKIM – adds a digital signature DMARC – tells email providers how to handle suspicious emails Free tool: ✔️ dmarcian’s free checker ✔️ MXToolbox DMARC Analyzer 2️⃣ Use Strong Filtering & Anti-Spam Controls Modern phishing is extremely sophisticated. Activate advanced filtering in: Google Workspace Microsoft 365 Zoho Mail Or use free/low-cost add-ons like SpamTitan (free trial) for small teams. These engines detect malicious links, spoofed sender IDs and suspicious attachments before they reach the inbox. 3️⃣ Train Users on Phishing Especially Year-End Scams December phishing themes often include: Fake gift cards Banking alerts HR document uploads “Your package is delayed” emails Fake holiday bonuses Urgent invoice or payment request from “CEO/Manager” Use Gophish (free) to run small awareness campaigns internally. Rule: If an email triggers emotion urgency, fear, excitement pause and verify. 4️⃣ Block High-Risk Attachments Most ransomware enters through: .exe, .js, .scr, .zip, .rar, .bat, .ps1 Configure email policy to block risky file types unless explicitly allowed for specific users. 5️⃣ Use Isolation for Email Links (Optional but Powerful) Tools like Cloudflare Browser Isolation or Menlo Security Free Tier open links in a sandbox, preventing malware from executing on user machines. 🔥 Real-Life Example: The 2021 Sony Fake Invoice Incident 🔥 A European Sony subsidiary lost over $3 million to a highly targeted phishing email. Attackers impersonated a trusted vendor, sent a “project invoice,” and the finance team unknowingly transferred the funds. No malware. No hacking. Just one email. Takeaway: Even reputable brands fall victim when email verification and financial controls are weak. 🛠️ Quick Wins for December 🛠️ Turn on DMARC with enforcement Use spam filtering with attachment controls Run a holiday themed phishing awareness test Warn employees about fake delivery notifications Educate teams to never process payments solely via email Enable safe-link scanning (M365/Workspace) Review shared mailboxes & disable unused accounts ⭐ Final Thoughts ⭐ Email will always be a favorite weapon for cybercriminals. But with the right mix of authentication, filtering, user training and simple controls, SMBs can drastically reduce their exposure. One secure email click protects the entire business. Make December your strongest month for phishing defense and start the new year safer than ever. Top comments (2) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Collapse Expand   bmo bmo bmo Follow Joined Dec 3, 2025 • Dec 3 '25 Dropdown menu Copy link Hide Very interesting - I guess in a world of increasing cyber crime something I have found extremely succesful and recommend to EVERYONE is an alias account, even if it is just to separate yourself from increasing spam, exploits, and vulnerabilities. Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Amit Ambekar Amit Ambekar Amit Ambekar Follow Joined Apr 30, 2025 • Dec 4 '25 Dropdown menu Copy link Hide Thank you for your valuable insight! Absolutely agree using an alias account is a smart and practical layer of protection. It helps reduce exposure to spam, phishing attempts and other attack vectors. I appreciate you sharing your experience here. Good security habits like these go a long way in today’s threat landscape! Like comment: Like comment: 1  like Like Comment button Reply Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse Amit Ambekar Follow Joined Apr 30, 2025 More from Amit Ambekar 🔍 November: Strengthening Identity & Access Management (IAM) for SMBs # iam # cybersecurity # soc # education 🔐 Cyber Awareness Month Special: Why Security is Everyone’s Responsibility! Beyond Roles and Job Titles... # cybersecurity # awareness 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV Security Forem — Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . Security Forem © 2016 - 2026. Share. Secure. Succeed Log in Create account	2026-01-13T08:49:46
https://python.swaroopch.com/	Introduction · A Byte of Python Introduction Dedication Preface About Python Installation First Steps Basics Operators and Expressions Control flow Functions Modules Data Structures Problem Solving Object Oriented Programming Input and Output Exceptions Standard Library More What Next Appendix: FLOSS Appendix: About Appendix: Revision History Appendix: Translations Appendix: Translation How-to Feedback Published with HonKit Introduction A Byte of Python "A Byte of Python" is a free book on programming using the Python language. It serves as a tutorial or guide to the Python language for a beginner audience. If all you know about computers is how to save text files, then this is the book for you. For Python version 3 This book will teach you to use Python version 3. There will also be guidance for you to adapt to the older and more common Python version 2 in the book. Who reads A Byte of Python? Here are what people are saying about the book: Somewhere around 2004 - 05 when I was convinced I wasn’t smart enough to be a programmer , I came came across the original A Byte of #Python, and that changed my entire perspective on computing and life , I owe a lot to that book @swaroopch had written. -- Rahul on Jul 30, 2020 This is the book that got me into programming almost a decade ago. Thank you @swaroopch. You changed my life. -- Stefan Froelich on Aug 2, 2019 I am writing this email to thank you for the great help your book has done for me! It was a really good book that I enjoyed thoroughly. As a 15 year old who has never done programming before, trying to learn Python online was difficult and I couldn't understand anything. But I felt like your book gave was much easier to understand and eased me into the whole new world of programming. Thanks to you, I can now write a high level language with ease. I thought programming would be hard and boring, but with your book's help, I realised how fun and interesting yet simple it can be! I would like to thank you again for your hard work on helping out beginners like me. -- Prottyashita Tahiyat on Sep 17, 2019 This is the best beginner's tutorial I've ever seen! Thank you for your effort. -- Walt Michalik The best thing i found was "A Byte of Python", which is simply a brilliant book for a beginner. It's well written, the concepts are well explained with self evident examples. -- Joshua Robin Excellent gentle introduction to programming #Python for beginners -- Shan Rajasekaran start to love python with every single page read -- Herbert Feutl perfect beginners guide for python, will give u key to unlock magical world of python -- Dilip I should be doing my actual "work" but just found "A Byte of Python". A great guide with great examples. -- Biologist John Recently started reading a Byte of python. Awesome work. And that too for free. Highly recommended for aspiring pythonistas. -- Mangesh A Byte of Python, written by Swaroop. (this is the book I'm currently reading). Probably the best to start with, and probably the best in the world for every newbie or even a more experienced user. -- Apostolos Enjoying Reading #ByteOfPython by @swaroopch best book ever -- Yuvraj Sharma A Byte of Python by @swaroopch is still the "Best newbie guide to python" -- Nickson Kaigi Thank you so much for writing A Byte Of Python. I just started learning how to code two days ago and I'm already building some simple games. Your guide has been a dream and I just wanted to let you know how valuable it has been. -- Franklin I'm from Dayanandasagar College of Engineering (7th sem, CSE). Firstly i want to say that your book "The byte of python" is too good a book for a beginner in python like me.The concepts are so well explained with simple examples that helped me to easily learn python. Thank you so much. -- Madhura I am a 18 year old IT student studying at University in Ireland. I would like to express my gratitude to you for writing your book "A Byte of Python", I already had knowledge of 3 programming langagues - C, Java and Javascript, and Python was by far the easiest langague I have ever learned, and that was mainly because your book was fantastic and made learning python very simple and interesting. It is one of the best written and easy to follow programming books I have ever read. Congratulations and keep up the great work. -- Matt Hi, I'm from Dominican Republic. My name is Pavel, recently I read your book A Byte of Python and I consider it excellent!! :). I learnt much from all the examples. Your book is of great help for newbies like me... -- Pavel Simo I am a student from China, Now ,I have read you book A byte of Python, Oh it's beautiful. The book is very simple but can help all the first learnners. You know I am interesting in Java and cloud computing many times, i have to coding programm for the server, so i think python is a good choice, finish your book, i think its not only a good choice its must use the Python. My English is not very well, the email to you, i just wanna thank you! Best Wishes for you and your family. -- Roy Lau I recently finished reading Byte of Python, and I thought I really ought to thank you. I was very sad to reach the final pages as I now have to go back to dull, tedious oreilly or etc. manuals for learning about python. Anyway, I really appreciate your book. Samuel Young Dear Swaroop, I am taking a class from an instructor that has no interest in teaching. We are using Learning Python, second edition, by O'Reilly. It is not a text for beginner without any programming knowledge, and an instructor that should be working in another field. Thank you very much for your book, without it I would be clueless about Python and programming. Thanks a million, you are able to break the message down to a level that beginners can understand and not everyone can. -- Joseph Duarte I love your book! It is the greatest Python tutorial ever, and a very useful reference. Brilliant, a true masterpiece! Keep up the good work! -- Chris-André Sommerseth First of all, I want to say thanks to you for this great book. I think it is a good book for those who are looking for a beginner's tutorial for Python. It is about two or there years ago, I think, when I first heard of this book. At that time, I was unable to read books in English yet, so I got a chinese translation, which took me into the gate of Python programming. Recently, I reread this book. This time, of course, the english version. I couldn't believe that I can read the whole book without my dictionary at hand. Of course, it all dues to your effort to make this book an easy-to-understand one. -- myd7349 I'm just e-mailing you to thank you for writing Byte of Python online. I had been attempting Python for a few months prior to stumbling across your book, and although I made limited success with pyGame, I never completed a program. Thanks to your simplification of the categories, Python actually seems a reachable goal. It seems like I have finally learned the foundations and I can continue into my real goal, game development. ... Once again, thanks VERY much for placing such a structured and helpful guide to basic programming on the web. It shoved me into and out of OOP with an understanding where two text books had failed. -- Matt Gallivan I would like to thank you for your book A Byte of Python which i myself find the best way to learn python. I am a 15 year old i live in egypt my name is Ahmed. Python was my second programming language i learn visual basic 6 at school but didn't enjoy it, however i really enjoyed learning python. I made the addressbook program and i was sucessful. i will try to start make more programs and read python programs (if you could tell me source that would be helpful). I will also start on learning java and if you can tell me where to find a tutorial as good as yours for java that would help me a lot. Thanx. -- Ahmed Mohammed A wonderful resource for beginners wanting to learn more about Python is the 110-page PDF tutorial A Byte of Python by Swaroop C H. It is well-written, easy to follow, and may be the best introduction to Python programming available. -- Drew Ames Yesterday I got through most of Byte of Python on my Nokia N800 and it's the easiest and most concise introduction to Python I have yet encountered. Highly recommended as a starting point for learning Python. -- Jason Delport Byte of Vim and Python by @swaroopch is by far the best works in technical writing to me. Excellent reads #FeelGoodFactor -- Surendran "Byte of python" best one by far man (in response to the question "Can anyone suggest a good, inexpensive resource for learning the basics of Python? ") -- Justin LoveTrue The Book Byte of python was very helpful ..Thanks bigtime :) Chinmay Always been a fan of A Byte of Python - made for both new and experienced programmers. -- Patrick Harrington I started learning python few days ago from your book..thanks for such a nice book. it is so well written, you made my life easy..so you found a new fan of yours..thats me :) tons of thanks. -- Gadadhari Bheem Before I started to learn Python, I've acquired basic programming skills in Assembly, C, C++, C# and Java. The very reason I wanted to learn Python is it's popular (people are talking about it) and powerful (reality). This book written by Mr. Swaroop is a very good guide for both brand-new programmers and new python programmers. Took 10 half days to go through it. Great Help! -- Fang Biyi (PhD Candidate ECE, Michigan State University) Thank you ever so much for this book!! This book cleared up many questions I had about certain aspects of Python such as object oriented programming. I do not feel like an expert at OO but I know this book helped me on a first step or two. I have now written several python programs that actually do real things for me as a system administrator. They are all procedural oriented but they are small by most peoples standards. Again, thanks for this book. Thank you for having it on the web. -- Bob I just want to thank you for writing the first book on programming I've ever really read. Python is now my first language, and I can just imagine all the possibilities. So thank you for giving me the tools to create things I never would have imagined I could do before. -- "The Walrus" I wanted to thank you for writing A Byte Of Python (2 & 3 Versions). It has been invaluable to my learning experience in Python & Programming in general. Needless to say, I am a beginner in the programming world, a couple of months of self study up to this point. I had been using youtube tutorials & some other online tutorials including other free books. I decided to dig into your book yesterday, & I've learned more on the first few pages than any other book or tutorial. A few things I had been confused about, were cleared right up with a GREAT example & explanation. Can't wait to read (and learn) more!! Thank you so much for not only writing the book, but for putting it under the creative commons license (free). Thank goodness there are unselfish people like you out there to help & teach the rest of us. -- Chris I wrote you back in 2011 and I was just getting into Python and wanted to thank you for your tutorial "A Byte of Python". Without it, I would have fallen by the wayside. Since then I have gone on to program a number of functions in my organization with this language with yet more on the horizon. I would not call myself an advanced programmer by any stretch but I notice the occasional request for assistance now from others since I started using it. I discovered, while reading "Byte" why I had ceased studying C and C++ and it was because the book given to me started out with an example containing an augmented assignment. Of course, there was no explanation for this arrangement of operators and I fell on my head trying to make sense of what was on the written page. As I recall it was a most frustrating exercise which I eventually abandoned. Doesn't mean C or C++ is impossible to learn, or even that I am stupid, but it does mean that the documentation I worked my way through did not define the symbols and words which is an essential part of any instruction. Just as computers will not be able to understand a computer word or computer symbol that is outside the syntax for the language being used, a student new to any field will not grasp his subject if he encounters words or symbols for which there are no definitions. You get a "blue screen" as it were in either case. The solution is simple, though: find the word or symbol and get the proper definition or symbol and lo and behold,the computer or student can proceed. Your book was so well put together that I found very little in it I couldn't grasp. So, thank you. I encourage you to continue to include full definitions of terms. The documentation with Python is good, once you know, (the examples are its strength from what I see) but in many cases it seems that you have to know in order to understand the documentation which to my mind is not what should be. Third party tutorials express the need for clarification of the documentation and their success largely depends on the words that are used to describe the terminology. I have recommended your book to many others. Some in Australia, some in the Caribbean and yet others in the US. It fills a niche no others do. I hope you are doing well and wish you all the success in the future. -- Nick hey, this is ankush(19). I was facing a great difficulty to start with python. I tried a lot of books but all were bulkier and not target oriented; and then i found this lovely one, which made me love python in no time. Thanks a lot for this "beautiful piece of book". -- Ankush I would like to thank you for your excellent guide on Python. I am a molecular biologist (with little programming background) and for my work I need to handle big datasets of DNA sequences and to analyse microscope images. For both things, programming in python has been useful, if not essential to complete and publish a 6-years project. That such a guide is freely available is a clear sign that the forces of evil are not yet ruling the world! :) -- Luca Since this is going to be the first language you learn, you should use A Byte of Python. It really gives a proper introduction into programming in Python and it is paced well enough for the average beginner. The most important thing from then on will be actually starting to practice making your own little programs. -- "{Unregistered}" Just to say a loud and happy thank you very much for publishing "A Byte of Python" and "A Byte of Vim". Those books were very useful to me four or five years ago when I starting learning programming. Right now I'm developing a project that was a dream for a long, long time and just want to say thank you . Keep walking. You are a source of motivation. All the best. -- Jocimar Finished reading A byte of Python in 3 days. It is thoroughly interesting. Not a single page was boring. I want to understand the Orca screen reader code. Your book has hopefully equipped me for it. -- Dattatray Hi, 'A byte of python' is really a good reading for python beginners. So, again, NICE WORK! i'm a 4 years experienced Java&C developer from China. Recently, i want to do some work on zim-wiki note project which uses pygtk to implement. i read your book in 6 days, and i can read and write python code examples now. thx for your contribution. plz keep your enthusiasm to make this world better, this is just a little encourage from China. -- Lee I am Isen from Taiwan, who is a graduating PhD student in Electrical Engineering Department of National Taiwan University. I would like to thank you for your great book. I think it is not only just easy to read but also comprehensive and complete for a new comer of Python. The reason I read your book is that I am starting to work on the GNU Radio framework. Your book let me catch most of important core ideas and skill of Python with a minimum time. I also saw that you do not mind that readers send you a thank note in your book. So I really like your book and appreciate it. Thanks. -- Isen I-Chun Chao The book is even used by NASA! It is used in their Jet Propulsion Laboratory with their Deep Space Network project. Academic Courses This book is/was being used as instructional material in various educational institutions: 'Principles of Programming Languages' course at Vrije Universiteit, Amsterdam 'Basic Concepts of Computing' course at University of California, Davis 'Programming With Python' course at Harvard University 'Introduction to Programming' course at University of Leeds 'Introduction to Application Programming' course at Boston University 'Information Technology Skills for Meteorology' course at University of Oklahoma 'Geoprocessing' course at Michigan State University 'Multi Agent Semantic Web Systems' course at the University of Edinburgh 'Introduction to Computer Science and Programming' at MIT OpenCourseWare 'Basic programming at the Faculty of Social Sciences, University of Ljubljana, Slovenia' -- Aleš Žiberna says "I (and my predecessor) have been using your book as the main literature for this course" 'Introduction to programming', Department of Information Sciences, University of Zadar, Croatia -- Krešimir Zauder says "I would like to inform you that A Byte of Python is a mandatory read at my course" License This book is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License . This means: You are free to Share i.e. to copy, distribute and transmit this book You are free to Remix i.e. to make changes to this book (especially translations) You are free to use it for commercial purposes Please note: Please do not sell electronic or printed copies of the book unless you have clearly and prominently mentioned in the description that these copies are not from the original author of this book. Attribution must be shown in the introductory description and front page of the document by linking back to https://python.swaroopch.com and clearly indicating that the original text can be fetched from this location. All the code/scripts provided in this book is licensed under the 3-clause BSD License unless otherwise noted. Read Now You can read it online at https://python.swaroopch.com Buy The Book A printed hardcopy of the book can be purchased at https://swaroopch.com/buybook/ for your offline reading pleasure, and to support the continued development and improvement of this book. Download Visit https://github.com/swaroopch/byte-of-python/releases/latest to download a PDF file (best for desktop reading) or an EPUB file (best for devices such as mobile, tablet, ebook readers). Visit https://github.com/swaroopch/byte-of-python for the raw content (for suggesting corrections, changes, translating, etc.) Read the book in your native language If you are interested in reading or contributing translations of this book to other human languages, please see Translations . results matching " " No results matching " "	2026-01-13T08:49:46
https://opensource.org/license/blue-oak-model-license	Blue Oak Model License – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Redundant with more popular Blue Oak Model License Version 1.0.0 Submitted: November 9, 2023 Submitter: Luis Villa Approved: January 19, 2024 Board minutes SPDX short identifier: BlueOak-1.0.0 Link to license steward's version Version 1.0.0 Purpose This license gives everyone as much permission to work with this software as possible, while protecting contributors from liability. Acceptance In order to receive this license, you must agree to its rules.  The rules of this license are both obligations under that agreement and conditions to your license. You must not do anything with this software that triggers a rule that you cannot or will not follow. Copyright Each contributor licenses you to do everything with this software that would otherwise infringe that contributor’s copyright in it. Notices You must ensure that everyone who gets a copy of any part of this software from you, with or without changes, also gets the text of this license or a link to https://blueoakcouncil.org/license/1.0.0 . Excuse If anyone notifies you in writing that you have not complied with [Notices](#notices), you can keep your license by taking all practical steps to comply within 30 days after the notice.  If you do not do so, your license ends immediately. Patent Each contributor licenses you to do everything with this software that would otherwise infringe any patent claims they can license or become able to license. Reliability No contributor can revoke this license. No Liability As far as the law allows, this software comes as is, without any warranty or condition, and no contributor will be liable to anyone for any damages related to this software or this license, under any kind of legal claim. Donate to the OSI The OSI is the authority that defines Open Source, recognized globally by individuals, companies, and public institutions. The Open Source Initiative (OSI) is a 501(c)3 public benefit corporation, founded in 1998. --> Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://forem.com/t/containers/page/7	Containers Page 7 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close # containers Follow Hide Security for container technologies like Docker and orchestration platforms like Kubernetes. Create Post Older #containers posts 4 5 6 7 8 9 10 11 12 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Working with Docker Containers: Essential Commands and Techniques 🐋 Haripriya Veluchamy Haripriya Veluchamy Haripriya Veluchamy Follow Nov 25 '25 Working with Docker Containers: Essential Commands and Techniques 🐋 # devops # cloud # docker # containers 3 reactions Comments 1 comment 4 min read Running Firefox in Docker? Yes, with a GUI and noVNC! Daniel Pepuho Daniel Pepuho Daniel Pepuho Follow Nov 21 '25 Running Firefox in Docker? Yes, with a GUI and noVNC! # docker # containers # linux # tutorial 8 reactions Comments 2 comments 3 min read Containerization for Data Engineering: A Practical Guide with Docker and Docker Compose J M J M J M Follow Nov 13 '25 Containerization for Data Engineering: A Practical Guide with Docker and Docker Compose # docker # dataengineering # devops # containers Comments Add Comment 2 min read Docker Use Case and Containerization of a Website 📦 Muhammad Hamid Raza Muhammad Hamid Raza Muhammad Hamid Raza Follow Nov 2 '25 Docker Use Case and Containerization of a Website 📦 # webdev # docker # containers # productivity 5 reactions Comments Add Comment 3 min read Logs Multiplexing in Docker Kelvin Amoaba Kelvin Amoaba Kelvin Amoaba Follow Oct 17 '25 Logs Multiplexing in Docker # docker # containers Comments Add Comment 3 min read Comandos Kubectl para Resolução de Problemas rafaelbonilha rafaelbonilha rafaelbonilha Follow Nov 21 '25 Comandos Kubectl para Resolução de Problemas # kubernetes # containers # cloud # docker 2 reactions Comments Add Comment 3 min read My First MLOps Project: From Model Training to Kubernetes Deployment 🚀 Aman Nikhare Aman Nikhare Aman Nikhare Follow Nov 19 '25 My First MLOps Project: From Model Training to Kubernetes Deployment 🚀 # mlops # kubernetes # containers # ai Comments Add Comment 5 min read Keep Calm and Use Docker Volumes Tshenolo Mos Tshenolo Mos Tshenolo Mos Follow Oct 16 '25 Keep Calm and Use Docker Volumes # docker # volumes # containers Comments Add Comment 3 min read 🎮 Understanding Linux Cgroups Ajinkya Singh Ajinkya Singh Ajinkya Singh Follow Nov 16 '25 🎮 Understanding Linux Cgroups # programming # containers # go # devops 4 reactions Comments Add Comment 5 min read LLPY-12: Docker y Containerización - De Desarrollo a Producción Jesus Oviedo Riquelme Jesus Oviedo Riquelme Jesus Oviedo Riquelme Follow Oct 17 '25 LLPY-12: Docker y Containerización - De Desarrollo a Producción # containers # devops # docker Comments Add Comment 11 min read The Ultimate Guide to Kubernetes Architecture — A Complete CKA-Level Deep Dive Sourav kumar Sourav kumar Sourav kumar Follow Oct 13 '25 The Ultimate Guide to Kubernetes Architecture — A Complete CKA-Level Deep Dive # kubernetes # containers # cka # architecture Comments Add Comment 5 min read Creating an Amazon ECS service that uses Service Discovery Learn2Skills Learn2Skills Learn2Skills Follow for AWS Community Builders Nov 17 '25 Creating an Amazon ECS service that uses Service Discovery # aws # containers # cloud # ecs 2 reactions Comments Add Comment 6 min read The Complete Docker Container Lifecycle: States, Namespaces, and Internal Workings Srinivasaraju Tangella Srinivasaraju Tangella Srinivasaraju Tangella Follow Nov 17 '25 The Complete Docker Container Lifecycle: States, Namespaces, and Internal Workings # containers # docker # linux # tutorial Comments Add Comment 6 min read Logic Apps Local Dev Tools: Visual Walkthrough Daniel Jonathan Daniel Jonathan Daniel Jonathan Follow Nov 15 '25 Logic Apps Local Dev Tools: Visual Walkthrough # docker # containers # logicapps # vscode 1 reaction Comments Add Comment 4 min read Understanding Container Magic: The Overlay Filesystem Story Ajinkya Singh Ajinkya Singh Ajinkya Singh Follow Nov 13 '25 Understanding Container Magic: The Overlay Filesystem Story # programming # docker # containers # devops 1 reaction Comments Add Comment 5 min read Complete Guide to Deploying Machine Learning Models with Flask and Docker(NO fluff configure and run like a pro) Mendy Kevin Mendy Kevin Mendy Kevin Follow Nov 2 '25 Complete Guide to Deploying Machine Learning Models with Flask and Docker(NO fluff configure and run like a pro) # machinelearning # docker # containers # pipenv 1 reaction Comments Add Comment 11 min read [Tips] [Podman] What to do if you get an "insufficient space" error when loading an image Masaki Okuda Masaki Okuda Masaki Okuda Follow Oct 8 '25 [Tips] [Podman] What to do if you get an "insufficient space" error when loading an image # tips # podman # containers Comments Add Comment 1 min read Debugging ECR Private Pull Through Cache Jason Butz Jason Butz Jason Butz Follow for AWS Community Builders Nov 12 '25 Debugging ECR Private Pull Through Cache # aws # containers Comments Add Comment 3 min read 🧩Scenario #16 — Horizontal Pod Autoscaling Using YAML Manifest in Kubernetes Latchu@DevOps Latchu@DevOps Latchu@DevOps Follow Nov 13 '25 🧩Scenario #16 — Horizontal Pod Autoscaling Using YAML Manifest in Kubernetes # kubernetes # cicd # devops # containers 6 reactions Comments 1 comment 2 min read 🧩Scenario #15 — Horizontal Pod Autoscaler (HPA) in Kubernetes Latchu@DevOps Latchu@DevOps Latchu@DevOps Follow Nov 13 '25 🧩Scenario #15 — Horizontal Pod Autoscaler (HPA) in Kubernetes # kubernetes # devops # cicd # containers 7 reactions Comments 1 comment 2 min read Mastering Modern Infrastructure: The Power of Cloud-Native and Serverless Architectures Rashi Rashi Rashi Follow Oct 8 '25 Mastering Modern Infrastructure: The Power of Cloud-Native and Serverless Architectures # cloudnative # microservices # containers # serverless Comments Add Comment 3 min read ✅ Scenario #14 – Integrate Kubernetes with Vault to fetch Secrets Latchu@DevOps Latchu@DevOps Latchu@DevOps Follow Nov 12 '25 ✅ Scenario #14 – Integrate Kubernetes with Vault to fetch Secrets # kubernetes # devops # cicd # containers 11 reactions Comments Add Comment 3 min read 🚀 Container Hardening: 12 Essential Rules for Secure and Optimized Docker Builds Waffeu Rayn Waffeu Rayn Waffeu Rayn Follow Nov 10 '25 🚀 Container Hardening: 12 Essential Rules for Secure and Optimized Docker Builds # containers # security # bestpractices # devops Comments Add Comment 4 min read 🐳 Docker Demystified — From Basics to Power Moves You’ll Actually Use Charan Gutti Charan Gutti Charan Gutti Follow Oct 7 '25 🐳 Docker Demystified — From Basics to Power Moves You’ll Actually Use # docker # beginners # devops # containers 1 reaction Comments Add Comment 5 min read Continuous integration with containers and inceptions Andre Faria Andre Faria Andre Faria Follow Nov 10 '25 Continuous integration with containers and inceptions # ci # containers # devops Comments Add Comment 5 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:46
https://dev.to/t/interview/page/78	Interview Page 78 - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close # interview Follow Hide Create Post Older #interview posts 75 76 77 78 79 80 81 82 83 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Having impressive side projects lets Big Tech recruiters know you are self motivated Daniel Daniel Daniel Follow Apr 16 '22 Having impressive side projects lets Big Tech recruiters know you are self motivated # programming # interview 8 reactions Comments Add Comment 4 min read CSS Interview Question: Center HTML Element (3 Approaches💥) Let's Code Let's Code Let's Code Follow Apr 19 '22 CSS Interview Question: Center HTML Element (3 Approaches💥) # css # interview # tutorial 9 reactions Comments 1 comment 2 min read Is Cracking the Coding Interview a good book to have? N E N E N E Follow Apr 14 '22 Is Cracking the Coding Interview a good book to have? # hiring # community # questions # interview 4 reactions Comments 1 comment 1 min read Top 10 Selenium interview questions rahul rahul rahul Follow Apr 13 '22 Top 10 Selenium interview questions # webdev # testing # automation # interview 3 reactions Comments Add Comment 5 min read Implement StrStr Isaac Tonyloi Isaac Tonyloi Isaac Tonyloi Follow Apr 12 '22 Implement StrStr # leetcode # problems # interview 6 reactions Comments Add Comment 2 min read Back of the Envelope Calculation Vladislav Vladislav Vladislav Follow Apr 10 '22 Back of the Envelope Calculation # interview # systemdesign 31 reactions Comments 3 comments 3 min read Coding Interviews in VR Daniel Daniel Daniel Follow Apr 8 '22 Coding Interviews in VR # interview # faang # coding # codinginterview 3 reactions Comments Add Comment 1 min read How to calculate total travel hours between city x and y and vice versa rajanand ilangovan rajanand ilangovan rajanand ilangovan Follow Mar 5 '22 How to calculate total travel hours between city x and y and vice versa # sqlserver # interview # questions 2 reactions Comments Add Comment 2 min read Problem solving Patterns gbenga fagbola gbenga fagbola gbenga fagbola Follow Apr 5 '22 Problem solving Patterns # javascript # algorithms # tutorial # interview 19 reactions Comments Add Comment 4 min read Frontend Interview questions I had with a Norwegian Startup Amin Gholamisani Amin Gholamisani Amin Gholamisani Follow Mar 30 '22 Frontend Interview questions I had with a Norwegian Startup # interview # javascript # css # react 25 reactions Comments Add Comment 2 min read How to solve a problem in a Technical Interview 😕 Shivam Gupta Shivam Gupta Shivam Gupta Follow Mar 10 '22 How to solve a problem in a Technical Interview 😕 # interview # programming # beginners 5 reactions Comments Add Comment 3 min read Function Currying in JavaScript ashwani3011 ashwani3011 ashwani3011 Follow Mar 29 '22 Function Currying in JavaScript # javascript # webdev # frontend # interview 11 reactions Comments Add Comment 2 min read Preparing for new opportunities as a Senior Developer. Aseem Gaurav Aseem Gaurav Aseem Gaurav Follow Mar 27 '22 Preparing for new opportunities as a Senior Developer. # interview # career # jobs # seniorengineer 13 reactions Comments 1 comment 7 min read What is buffer cache in oracle RK RK RK Follow Feb 21 '22 What is buffer cache in oracle # ora # database # buffercache # interview 3 reactions Comments Add Comment 1 min read Frontend Internship Interview Experience Ashutosh Dash Ashutosh Dash Ashutosh Dash Follow Mar 27 '22 Frontend Internship Interview Experience # javascript # react # internship # interview 9 reactions Comments 1 comment 3 min read DevOps Lead Takes on DevOps, DevSecOps, Culture, Processes, and Mindset Davide 'CoderDave' Benvegnù Davide 'CoderDave' Benvegnù Davide 'CoderDave' Benvegnù Follow Mar 22 '22 DevOps Lead Takes on DevOps, DevSecOps, Culture, Processes, and Mindset # devops # interview # devsecops # culture 7 reactions Comments Add Comment 2 min read What I’ve learned doing technical interviews Jack Marchant Jack Marchant Jack Marchant Follow Mar 18 '22 What I’ve learned doing technical interviews # interviewing # technical # interview # candidate 5 reactions Comments Add Comment 6 min read Stack Data Structure in JavaScript TK TK TK Follow Mar 16 '22 Stack Data Structure in JavaScript # algorithms # javascript # computerscience # interview 9 reactions Comments Add Comment 4 min read Queue Data Structure in JavaScript TK TK TK Follow Mar 16 '22 Queue Data Structure in JavaScript # algorithms # javascript # computerscience # interview 7 reactions Comments Add Comment 4 min read Why I Stopped Interviewing with Companies That Require a Coding Test Bradston Henry Bradston Henry Bradston Henry Follow Feb 2 '22 Why I Stopped Interviewing with Companies That Require a Coding Test # discuss # programming # career # interview 444 reactions Comments 152 comments 8 min read System Design Interview Question: Implementing a Scheduler Dmitrii Dmitrii Dmitrii Follow Mar 5 '22 System Design Interview Question: Implementing a Scheduler # interview # scheduler # dotnet # cronjob 65 reactions Comments Add Comment 9 min read Javascript interview questions Mohamed Elazap Mohamed Elazap Mohamed Elazap Follow Mar 6 '22 Javascript interview questions # jrazap # javascript # webdev # interview 3 reactions Comments Add Comment 1 min read Interview Questions: Singleton Pattern vs the Static Keyword Paula Fahmy Paula Fahmy Paula Fahmy Follow Mar 4 '22 Interview Questions: Singleton Pattern vs the Static Keyword # design # software # architecture # interview 7 reactions Comments Add Comment 11 min read Wildcard Matching Explained Daniel Daniel Daniel Follow Mar 4 '22 Wildcard Matching Explained # interview # career 4 reactions Comments Add Comment 1 min read Arrays in JS Sakshi J Sakshi J Sakshi J Follow Mar 3 '22 Arrays in JS # computerscience # interview # programming # beginners 6 reactions Comments Add Comment 1 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://pythoninsider.blogspot.com/	Python Insider Python core development news and information. Tuesday, December 16, 2025 Python 3.15.0 alpha 3 This is an early developer preview of Python 3.15 www.python.org/downloads/release/python-3150a3/ Major new features of the 3.15 series, compared to 3.14 Python 3.15 is still in development. This release, 3.15.0a3, is the third of seven planned alpha releases. Alpha releases are intended to make it easier to test the current state of new features and bug fixes and to test the release process. During the alpha phase, features may be added up until the start of the beta phase (2026-05-05) and, if necessary, may be modified or deleted up until the release candidate phase (2026-07-28). Please keep in mind that this is a preview release and its use is not recommended for production environments. Many new features for Python 3.15 are still being planned and written. Among the new major new features and changes so far: PEP 799 : A new high-frequency, low-overhead, statistical sampling profiler and dedicated profiling package PEP 686 : Python now uses UTF-8 as the default encoding PEP 782 : A new PyBytesWriter C API to create a Python bytes object Improved error messages (Hey, fellow core developer, if a feature you find important is missing from this list, let Hugo know.) The next pre-release of Python 3.15 will be 3.15.0a4, currently scheduled for 2026-01-13. More resources Online documentation PEP 790 , 3.15 release schedule Report bugs at https://github.com/python/cpython/issues Help fund Python directly (or via GitHub Sponsors ) and support the Python community And now for something completely different Instantly the captain ran forward, and in a loud voice commanded his crew to desist from hoisting the cutting-tackles, and at once cast loose the cables and chains confining the whales to the ship. “What now?” said the Guernsey-man, when the Captain had returned to them. “Why, let me see; yes, you may as well tell him now that—that—in fact, tell him I’ve diddled him, and (aside to himself) perhaps somebody else.” Enjoy the new release Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organisation contributions to the Python Software Foundation . Regards from an even deeper darker Helsinki, Your release team, Hugo van Kemenade Ned Deily Steve Dower Łukasz Langa Posted by Hugo at 9:44 AM Email This BlogThis! Share to X Share to Facebook Share to Pinterest Labels: releases Friday, December 5, 2025 Python 3.14.2 and 3.13.11 are now available! Two more, just three days after the last? Yes! We found some regressions, so here’s an expedited pair of releases. They also come with some bonus security fixes. Python 3.14.2 www.python.org/downloads/release/python-3142/ Python 3.14.2 is the second maintenance release of 3.14, containing 18 bugfixes, build improvements and documentation changes since 3.14.1. This is an expedited release to fix the following regressions: gh-142206 : Exceptions in multiprocessing in running programs while upgrading Python. gh-142214 : Exceptions in dataclasses without __init__ method. gh-142218 : Segmentation faults and assertion failures in insertdict. gh-140797 : Crash when using multiple capturing groups in re.Scanner And these security fixes: gh-142145 : Remove quadratic behavior in node ID cache clearing ( CVE-2025-12084 ) gh-119452 : Fix a potential virtual memory allocation denial of service in http.server See the full changelog . Python 3.13.11 www.python.org/downloads/release/python-31311/ Python 3.13.11 is the eleventh maintenance release of 3.13. This is an expedited release to fix the following regressions: gh-142206 : Exceptions in multiprocessing in running programs while upgrading Python. gh-142218 : Segmentation faults and assertion failures in insertdict. gh-140797 : Crash when using multiple capturing groups in re.Scanner And these security fixes: gh-142145 : Remove quadratic behavior in node ID cache clearing ( CVE-2025-12084 ) gh-119451 : Fix a potential denial of service in http.client gh-119452 : Fix a potential virtual memory allocation denial of service in http.server See the full changelog . Enjoy the new release Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organisation contributions to the Python Software Foundation . Regards from deeper darker Helsinki, Your release team, Hugo van Kemenade Thomas Wouters Ned Deily Steve Dower Łukasz Langa Posted by Hugo at 4:29 PM Email This BlogThis! Share to X Share to Facebook Share to Pinterest Labels: releases Tuesday, December 2, 2025 Python 3.13.10 is now available, too, you know! The latest version of Python 3.13 is now available! Python 3.13.10   https://www.python.org/downloads/release/python-31310/ This is the tenth maintenance release of Python 3.13 Python 3.13.10 is the tenth maintenance release of 3.13, containing around 300 bugfixes, build improvements and documentation changes since 3.13.9. Full Changelog More resources Online Documentation PEP 719 , 3.13 Release Schedule Report bugs at https://github.com/python/cpython/issues . Help fund Python directly (or via GitHub Sponsors ), and support the Python community .   Enjoy the new releases Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organization contributions to the Python Software Foundation. Regards from your package managers, Thomas Wouters Ned Deily Steve Dower Łukasz Langa Posted by Thomas Wouters at 1:50 PM Email This BlogThis! Share to X Share to Facebook Share to Pinterest Labels: releases Python 3.14.1 is now available! This is first maintenance release of Python 3.14 Python 3.14.1 is the first maintenance release of 3.14, containing around 558 bugfixes, build improvements and documentation changes since 3.14.0. Major new features of the 3.14 series, compared to 3.13 Some of the major new features and changes in Python 3.14 are: New features PEP 779 : Free-threaded Python is officially supported PEP 649 : The evaluation of annotations is now deferred, improving the semantics of using annotations. PEP 750 : Template string literals (t-strings) for custom string processing, using the familiar syntax of f-strings. PEP 734 : Multiple interpreters in the stdlib. PEP 784 : A new module compression.zstd providing support for the Zstandard compression algorithm. PEP 758 : except and except* expressions may now omit the brackets. Syntax highlighting in PyREPL , and support for color in unittest , argparse , json and calendar CLIs. PEP 768 : A zero-overhead external debugger interface for CPython. UUID versions 6-8 are now supported by the uuid module, and generation of versions 3-5 are up to 40% faster. PEP 765 : Disallow return / break / continue that exit a finally block. PEP 741 : An improved C API for configuring Python. A new type of interpreter . For certain newer compilers, this interpreter provides significantly better performance. Opt-in for now, requires building from source. Improved error messages. Builtin implementation of HMAC with formally verified code from the HACL* project. A new command-line interface to inspect running Python processes using asynchronous tasks. The pdb module now supports remote attaching to a running Python process . For more details on the changes to Python 3.14, see What’s new in Python 3.14 . Build changes PEP 761 : Python 3.14 and onwards no longer provides PGP signatures for release artifacts. Instead, Sigstore is recommended for verifiers. Official macOS and Windows release binaries include an experimental JIT compiler . Official Android binary releases are now available. Incompatible changes, removals and new deprecations Incompatible changes Python removals and deprecations C API removals and deprecations Overview of all pending deprecations Python install manager The installer we offer for Windows is being replaced by our new install manager, which can be installed from the Windows Store or from its download page . See our documentation for more information. The JSON file available for download contains the list of all the installable packages available as part of this release, including file URLs and hashes, but is not required to install the latest release. The traditional installer will remain available throughout the 3.14 and 3.15 releases. More resources Online documentation PEP 745 , 3.14 Release Schedule Report bugs at github.com/python/cpython/issues Help fund Python directly (or via GitHub Sponsors ) and support the Python community And now for something completely different Seki Takakazu (関孝和; c. March 1642 – December 5, 1708) was a Japanese mathematician and samurai who laid the foundations of Japanese mathematics, later known as wasan (和算, from wa (“Japanese”) and san (“calculation”). Seki was a contemporary of Isaac Newton and Gottfried Leibniz but worked independently. He created a new algebraic system, worked on infinitesimal calculus, and is credited with the discovery of Bernoulli numbers (before Bernoulli’s birth). Seki also calculated π to 11 decimal places using a polygon with 131,072 sides inscribed within a circle, using an acceleration method now known as Aitken’s delta-squared process, which was rediscovered by Alexander Aitken in 1926. Enjoy the new release Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organisation contributions to the Python Software Foundation . Regards from deepest darkest Helsinki, Your release team, Hugo van Kemenade Ned Deily Steve Dower Łukasz Langa Posted by Hugo at 11:43 AM Email This BlogThis! Share to X Share to Facebook Share to Pinterest Labels: releases Wednesday, November 19, 2025 Python 3.15.0 alpha 2 This is an early developer preview of Python 3.15 https://www.python.org/downloads/release/python-3150a2/ Major new features of the 3.15 series, compared to 3.14 Python 3.15 is still in development. This release, 3.15.0a2, is the second of seven planned alpha releases. Alpha releases are intended to make it easier to test the current state of new features and bug fixes and to test the release process. During the alpha phase, features may be added up until the start of the beta phase (2026-05-05) and, if necessary, may be modified or deleted up until the release candidate phase (2026-07-28). Please keep in mind that this is a preview release and its use is not recommended for production environments. Many new features for Python 3.15 are still being planned and written. Among the new major new features and changes so far: PEP 799 : A new high-frequency, low-overhead, statistical sampling profiler and dedicated profiling package PEP 686 : Python now uses UTF-8 as the default encoding PEP 782 : A new PyBytesWriter C API to create a Python bytes object Improved error messages (Hey, fellow core developer, if a feature you find important is missing from this list, let Hugo know.) The next pre-release of Python 3.15 will be 3.15.0a3, currently scheduled for 2025-12-16. More resources Online documentation PEP 790 , 3.15 release schedule Report bugs at https://github.com/python/cpython/issues Help fund Python directly (or via GitHub Sponsors ) and support the Python community And now for something completely different “An hour,” said Ahab, standing rooted in his boat’s stern; and he gazed beyond the whale’s place, towards the dim blue spaces and wide wooing vacancies to leeward. It was only an instant; for again his eyes seemed whirling round in his head as he swept the watery circle. The breeze now freshened; the sea began to swell. “The birds!—the birds!” cried Tashtego. Enjoy the new release Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organisation contributions to the Python Software Foundation . Regards from a crisp and sunny subzero Helsinki, Your release team, Hugo van Kemenade Ned Deily Steve Dower Łukasz Langa Posted by Hugo at 4:56 AM Email This BlogThis! Share to X Share to Facebook Share to Pinterest Labels: releases Wednesday, October 15, 2025 Python 3.15.0 alpha 1 This is an early developer preview of Python 3.15 https://www.python.org/downloads/release/python-3150a1/ Major new features of the 3.15 series, compared to 3.14 Python 3.15 is still in development. This release, 3.15.0a1, is the first of seven planned alpha releases. Alpha releases are intended to make it easier to test the current state of new features and bug fixes and to test the release process. During the alpha phase, features may be added up until the start of the beta phase (2026-05-05) and, if necessary, may be modified or deleted up until the release candidate phase (2026-07-28). Please keep in mind that this is a preview release and its use is not recommended for production environments. Many new features for Python 3.15 are still being planned and written. Among the new major new features and changes so far: PEP 799 : A dedicated profiling package for Python profiling tools PEP 686 : Python now uses UTF-8 as the default encoding PEP 782 : A new PyBytesWriter C API to create a Python bytes object Improved error messages (Hey, fellow core developer, if a feature you find important is missing from this list, let Hugo know.) The next pre-release of Python 3.15 will be 3.15.0a2, currently scheduled for 2025-11-18. More resources Online documentation PEP 790 , 3.15 Release Schedule Report bugs at https://github.com/python/cpython/issues Help fund Python directly (or via GitHub Sponsors ) and support the Python community And now for something completely different And hence not only at substantiated times, upon well known separate feeding-grounds, could Ahab hope to encounter his prey; but in crossing the widest expanses of water between those grounds he could, by his art, so place and time himself on his way, as even then not to be wholly without prospect of a meeting. Enjoy the new release Thanks to all of the many volunteers who help make Python Development and these releases possible! Please consider supporting our efforts by volunteering yourself or through organisation contributions to the Python Software Foundation . Regards from Helsinki before the first PyCon Finland in 9 years, Your release team, Hugo van Kemenade Ned Deily Steve Dower Łukasz Langa Posted by Hugo at 2:13 AM Email This BlogThis! Share to X Share to Facebook Share to Pinterest Labels: releases Tuesday, October 14, 2025 Python 3.13.9 is now available!   Python 3.13.9   https://www.python.org/downloads/release/python-3139/   3.13.9 is an expedited release containing a fix for one specific regression in Python 3.13.8: gh-139783 : Fix inspect.getsourcelines for the case when a decorator is followed by a comment or an empty line. There are no other changes in this release, compared to 3.13.8. More resources 3.13 online documentation PEP 745 , 3.13 release schedule Report bugs at github.com/python/cpython/issues Help fund Python and its community    Enjoy the new releases   Thanks to all of the many volunteers who help make Python Development and this release possible! Please consider supporting our efforts by volunteering yourself or through organisation contributions to the Python Software Foundation . Your expedited release team, Your release team, Thomas Wouters Ned Deily Steve Dower Łukasz Langa Posted by Thomas Wouters at 3:07 PM Email This BlogThis! Share to X Share to Facebook Share to Pinterest Labels: releases Older Posts Home Subscribe to: Comments (Atom) Subscribe Subscribe to Python Insider via RSS , or Twitter Related Links python.org Python-Dev mailing list Python Developer's Guide Translations Chinese (Simplified) Chinese (Traditional) French German Japanese Korean Portuguese Romanian Russian Spanish Python-Dev Blogs Eli Bendersky Summary of reading: October - December 2025 1 week ago PyPy Status Blog HPy kick-off sprint report 6 years ago Pumpichank Creating Python Snaps 10 years ago Tim Golden London Python Dojo December 2014 11 years ago R. David Murray Asyncio Implementation Overview 11 years ago The Voidspace Techie Blog unittest.mock and mock 1.0 alpha 1 13 years ago Tarek Ziadé More privacy please 13 years ago Deep Thoughts by Raymond Hettinger Python’s super() considered super! 14 years ago Jesse Noller Senthil Kumaran Brett Cannon Boredom & Laziness Brian Curtin Blog Archive ▼  2025 (25) ▼  December (4) Python 3.15.0 alpha 3 Python 3.14.2 and 3.13.11 are now available! Python 3.13.10 is now available, too, you know! Python 3.14.1 is now available! ►  November (1) ►  October (5) ►  September (1) ►  August (2) ►  July (2) ►  June (3) ►  May (2) ►  April (1) ►  March (1) ►  February (2) ►  January (1) ►  2024 (22) ►  December (2) ►  November (1) ►  October (4) ►  September (1) ►  August (2) ►  July (1) ►  June (3) ►  May (1) ►  April (2) ►  March (2) ►  February (2) ►  January (1) ►  2023 (18) ►  December (2) ►  November (1) ►  October (3) ►  September (2) ►  August (2) ►  July (1) ►  June (2) ►  May (1) ►  April (1) ►  March (1) ►  February (1) ►  January (1) ►  2022 (23) ►  December (1) ►  November (1) ►  October (4) ►  September (2) ►  August (2) ►  July (2) ►  June (2) ►  May (3) ►  April (1) ►  March (3) ►  February (1) ►  January (1) ►  2021 (24) ►  December (2) ►  November (2) ►  October (2) ►  September (2) ►  August (2) ►  July (1) ►  June (3) ►  May (1) ►  April (3) ►  March (1) ►  February (4) ►  January (1) ►  2020 (32) ►  December (2) ►  November (2) ►  October (2) ►  September (3) ►  August (3) ►  July (4) ►  June (4) ►  May (2) ►  April (4) ►  March (3) ►  February (2) ►  January (1) ►  2019 (36) ►  December (3) ►  November (1) ►  October (8) ►  September (1) ►  August (3) ►  July (5) ►  June (3) ►  May (2) ►  March (7) ►  February (3) ►  2018 (24) ►  December (2) ►  October (2) ►  September (1) ►  August (1) ►  June (2) ►  May (3) ►  April (3) ►  March (5) ►  February (2) ►  January (3) ►  2017 (17) ►  December (2) ►  October (2) ►  September (3) ►  August (2) ►  July (3) ►  June (1) ►  March (2) ►  January (2) ►  2016 (18) ►  December (5) ►  November (1) ►  October (2) ►  September (2) ►  August (1) ►  July (1) ►  June (5) ►  May (1) ►  2015 (14) ►  December (2) ►  November (1) ►  September (3) ►  August (1) ►  July (1) ►  June (1) ►  May (2) ►  March (2) ►  January (1) ►  2014 (8) ►  December (1) ►  November (1) ►  May (1) ►  March (3) ►  February (2) ►  2013 (5) ►  November (2) ►  October (1) ►  March (1) ►  February (1) ►  2012 (9) ►  December (1) ►  November (1) ►  October (2) ►  August (1) ►  June (2) ►  May (1) ►  March (1) ►  2011 (25) ►  August (2) ►  July (3) ►  June (1) ►  May (7) ►  April (7) ►  March (5) Contributors A.M. Kuchling Alfonso de la Guarda Anthony Scopatz Antoine P. Benjamin Peterson Brian Curtin Davidmh Donald Stufft Doug Hellmann Ee Durbin Ezio Melotti Georg Brandl Hugo Jacob Coffee Jesse Kelsey Hightower Larry Hastings Mathieu Leduc-Hamel Michael Markert Mike Driscoll Ned Deily Pablo Galindo Paul Moore Philip Jenvey Sumana Harihareswara Thomas Wouters Unknown Unknown Łukasz Langa Éric Araujo e haypo tp Copyright Python Insider by the Python Core Developers is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License . Based on a work at blog.python.org . Powered by Blogger .	2026-01-13T08:49:46
https://opensource.org/ai/process#content	Open Source AI Process – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Source AI Open Source AI OSAID 1.0 Process Timeline Open Weights FAQ Endorsements Open Main Menu THE open source ai definition 1.0 We have released the first stable version of the Definition. Read version 1.0 How was Open Source AI defined? The Open Source Definition is a practical guide to judge if legal documents grant the four freedoms to software, following the principles of the GNU Manifesto. More than two decades passed between the GNU Manifesto and the writing of the Open Source Definition . For AI we cannot wait decades to produce a new document. The Open Source Initiative started coordinating in 2022 a global process to sharpen collective knowledge and identify the principles that lead to a widely adopted Open Source AI Definition (OSAID). OSI brought together global experts to establish a shared set of principles that can recreate permissionless, pragmatic and simplified collaboration for AI practitioners, similar to that which the Open Source Definition has done for the software ecosystem. The output of this work is version 1.0 of the Open Source AI Definition . The document will be used to validate whether an AI system is an Open Source AI, or not. The validation process will be similar to the evaluation of existing licenses for software: community-led, open and public. The Process The board requires by the in-person meeting of 2024 in Raleigh, an Open Source AI Definition that is supported by stakeholders that include deployers of AI, end users of AI and subjects (those affected by AI decisions), provides positive examples of AI systems, is rooted in current practice and provides a reference for interested parties. Collaboration with multiple stakeholders The Open Source Initiative (OSI) has guarded the Open Source Definition for over 25 years and has robust processes for developing, amending, and consulting on licenses. This authority position is recognised by a number of leaders in organizations who have agreed to co-design a new definition suited for AI and ML. These leaders joined the co-design process in a personal capacity and with various degrees of direct involvement from their employers like Digital Public Goods Alliance, Mozilla Foundation, Open Knowledge Foundation, National Endowment for Democracy, Center for Tech and Civic Life, Code for America, Wikimedia Foundation, Creative Commons, Linux Foundation, MLCommons, EleutherAI, Open Future, GitHub, Microsoft, Google, DataStax, Amazon, Meta, Hugging Face, GIZ FAIR Forward – AI for All, OpenLLM France, Polytechnic Institute of Paris, Intel, Apache Software Foundation, Samsung, and the United Nations International Telecommunications Union (ITU). Co-design process Co-design, also called participatory or human-centered design, is a set of creative methods used to solve communal problems by sharing knowledge and power. The co-design methodology addresses the challenges of reaching an agreed definition within a diverse community (Costanza-Chock, 2020: Escobar, 2018: Creative Reaction Lab, 2018: Friedman et al., 2019). As noted in MIT Technology Review’s article about this project, “ [t]he open-source community is a big tent… encompassing everything from hacktivists to Fortune 500 companies…. With so many competing interests to consider, finding a solution that satisfies everyone while ensuring that the biggest companies play along is no easy task. ” (Gent, 2024). The co-design method allows us to integrate these diverging perspectives into one just, cohesive, and feasible standard. Support from such a significant and broad group of people also creates a tension to be managed between moving swiftly enough to deliver outputs that can be used operationally, and taking the time to consult widely to understand the big issues and garner community buy-in.  The first step of the co-design process was to identify the freedoms needed for Open Source AI. After various online and in-person activities and discussions , including five workshops across the world, the community adopted the four freedoms for software, now adapted for AI systems. The next step was to form four working groups to initially analyze four AI systems. To achieve better representation, special attention was given to diversity, equity and inclusion. Over 50% of the working group participants are people of color, 30% are black, 75% were born outside the US and 25% are women, trans and nonbinary. These working groups discussed and voted on which AI system components should be required to satisfy the four freedoms for AI. The components we adopted are described in the Model Openness Framework developed by the Linux Foundation. The vote compilation was performed based on the mean total votes per component (μ). Components which received over 2μ votes were marked as required and between 1.5μ and 2μ were marked likely required. Components that received between 0.5μ and μ were marked likely not required and less than 0.5μ as not required. The working groups evaluated legal frameworks and legal documents for each component. Finally, each working group published a recommendation report. The end result is the OSAID with a comprehensive definition checklist encompassing a total of 17 components. More working groups are being formed to evaluate how well other AI systems align with the definition. OSAID multi-stakeholder co-design process: from component list to a definition checklist The Open Source AI Definition Process We have released the first stable version Read version 1.0 RC1 Published in early October The draft is completed in all its parts The draft is supported by at least 2 representatives for each of the 6 stakeholder groups Stable version Outcome of in-person and online meetings through the summer/early autumn The document is endorsed by at least 5 reps for each of the stakeholder groups Announced in late October See the 2023 project activity February 2024 Call For Volunteers + Activity Feedback and Revision FOSDEM talk (Brussels) Bi-Weekly Virtual Public Town halls. Draft 0.0.5 March Virtual System Review Meetings Begin Draft 0.0.6 April Virtual System Review Meetings Continue Open Source Summit North America workshop The Free Software Legal and Licensing Event workshop Draft 0.0.7 May Virtual System Review Meetings END PyCon workshop (Pittsburgh) Draft 0.0.8 June Feedback Informs Content of OSI In-Person Stakeholder Meeting OW2 talk (Paris) Open Expo Europe talk(Madrid) RC 1 July OSPOs for Good panel session (New York) OSCA Community webinar (Virtual) August AI_dev talk (Hong Kong) Open Source Congress talk (Beijing) 0.0.9 September Deep Learning Indaba talk (Dakar) India FOSS talk (Bangalore) OSS Europe talk (Vienna) Nerdearla talk (Buenos Aires) Release Candidate 1 October Data in OSAI workshop (Paris) OCX talk (Mainz) All Things Open Stable Version Presentation (Raleigh) Release Stable Version Ongoing It doesn’t end with the Stable Version We’ll need to define rules for maintenance and review of the Definition. The OSI board of directors approved the creation of a new committee to oversee the development of the Open Source AI Definition, approve the Stable Version and set rules for the maintenance of Definition. Who is involved in this process? 🛠️ System Creators Makes AI system and/or component that will be studied, used, modified, or shared through an open source license. 📃 License Creators Writes or edits the open source license to be applied to the AI system or component; includes compliance. 🏛️ Regulators Writes or edits rules governing licenses and systems (e.g. government policy-maker). 🎓 Licensees Seeks to study, use modify, or share an open source AI system (e.g. AI engineer, health researcher, education researcher) ⌨️ End Users Consumes a system output, but does not seek to study, use, modify, or share the system (e.g., student using a chatbot to write a report, artist creating an image) 🙇 Subjects Affected upstream or downstream by a system output without interacting with it intentionally; includes advocates for this group (e.g. people with loan denied, or content creators). Governance Governance for the project is provided by the OSI Board of Directors . The OSI board members have expertise in business, legal, and open source software development, as well as experience across a range of commercial, public sector, and non-profit organizations. Formal progress reports including achievements, budget updates, and next steps are provided monthly by the Program Lead for advice and guidance as part of regular Board business. Additionally, informal updates on the outcomes of key meetings and milestones are provided via email to the Board as required. Details of the current Board, including profiles for each Director are available on here . How to participate The OSAID co-design process is open to everyone interested in collaborating . There are many ways to get involved: Join the working groups : be part of a team to evaluate various models against the OSAID. Join the forum : support and comment on the documents, record your approval or concerns to new and existing threads. Follow the weekly recaps : subscribe to our newsletter and blog to be kept up-to-date. Watch the town hall recordings to learn more about the process. Join the workshops and scheduled conferences : meet the OSI and other participants at in person events around the world. Endorse the Open Source AI Definition : have your organization added to the list of supporters of the OSAID. Previous Work Deep Dive AI Webinar Series 2023 Speakers from law, academia, enterprise, NGOs, and the OSS community presented webinars addressing pressing issues and potential solutions in our use and development of AI systems.  All Things Open – Deep Dive AI 2023 After two community reviews and a first pass at comments, we released a new draft version. The base is a preamble to explain “why Open Source AI”, followed by the beginning of a formal definition. 2022 Deep Dive AI Podcasts We released a series of 6 podcasts with experts on the matter to discuss all various aspects of Open Source AI. 2022 Panel Discussions Four experts in Business, Society, Legal, Academia further dissect the issues posed by AI systems. Deep Dive AI: The 2023 Report Update By bringing together experts from various domains, the OSI is actively contributing to the discourse on Open Source AI, laying the groundwork for a future where the principles of openness, transparency, and collaboration continue to underpin the evolution of cutting-edge technologies for the benefit of society as a whole. Read the 2023 Update Deep Dive AI: The 2022 Report What does it mean for an AI system to be Open Source? This report summarizes the discussions above and underscores what we’ve learned about the challenges and opportunities for the Open Source movement posed by AI. Read the 2022 Report Supported by OSI’s efforts wouldn’t be possible without the support of our sponsors and thousands of individual members. Become a sponsor or join us today! Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://opensource.org/?p=134740	Maintainers – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Home Maintainers Supporting maintainers and protecting the Open Source ecosystem Download the book How the OSI supports maintainers OSI Approved Licenses We provide a venue for the community to discuss Open Source licenses and we maintain the OSI Approved Licenses database. Policy & Standards We defend maintainers by educating legislators and policy makers about the Open Source ecosystem, its role in innovation and its value for an open future. We have engaged with NTIA, CISA, and policy makers of the EU Cyber Resilience Act, the EU AI Act, and the US Securing Open Source Software Act. Advocacy & Research We lead global conversations with maintainers, developers, non-profits, and lawyers to improve the understanding of Open Source. OSI investigates the impacts of ongoing debates from artificial intelligence to security. Join OSI and help maintainers too The generous contributions of people like you are the driving force behind OSI’s initiatives. Every dollar you  donate  directly supports our efforts to strengthen the OSI and protect the Open Source ecosystem. Join OSI Download the book Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://twitter.com/intent/tweet?text=%22XCode%20Cloud%20Build%20fails%20due%20Command%20exited%20with%20non-zero%20exit-code%3A%2070%22%20by%20Alexander%20Hodes%20%23DEVCommunity%20https%3A%2F%2Fdev.to%2Falexanderhodes%2Fxcode-cloud-build-fails-due-command-exited-with-non-zero-exit-code-70-6aj	JavaScript is not available. We’ve detected that JavaScript is disabled in this browser. Please enable JavaScript or switch to a supported browser to continue using x.com. You can see a list of supported browsers in our Help Center. Help Center Terms of Service Privacy Policy Cookie Policy Imprint Ads info © 2026 X Corp. Something went wrong, but don’t fret — let’s give it another shot. Try again Some privacy related extensions may cause issues on x.com. Please disable them and try again.	2026-01-13T08:49:46
https://www.youtube.com/@coreyms/courses	Corey Schafer - YouTube 정보 보도자료 저작권 문의하기 크리에이터 광고 개발자 약관 개인정보처리방침 정책 및 안전 YouTube 작동의 원리 새로운 기능 테스트하기 © 2026 Google LLC, Sundar Pichai, 1600 Amphitheatre Parkway, Mountain View CA 94043, USA, 0807-882-594 (무료), yt-support-solutions-kr@google.com, 호스팅: Google LLC, 사업자정보 , 불법촬영물 신고 크리에이터들이 유튜브 상에 게시, 태그 또는 추천한 상품들은 판매자들의 약관에 따라 판매됩니다. 유튜브는 이러한 제품들을 판매하지 않으며, 그에 대한 책임을 지지 않습니다.	2026-01-13T08:49:46
https://dev.to/vishalmysore	vishalmysore - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Follow User actions vishalmysore Experienced Software Architect and Developer. Hold Multiple patents on software Engineering and AI Location Toronto Joined Joined on Mar 26, 2024 Personal website https://github.com/vishalmysore/ github website More info about @vishalmysore Badges One Year Club This badge celebrates the longevity of those who have been a registered member of the DEV Community for at least one year. Got it Close Writing Debut Awarded for writing and sharing your first DEV post! Continue sharing your work to earn the 4 Week Writing Streak Badge. Got it Close Currently learning Gemini, OpenAI, Anthropic Currently hacking on AI Post 95 posts published Comment 1 comment written Tag 0 tags followed Building Interactive Data Visualizations in A2UI Angular: A Complete Guide vishalmysore vishalmysore vishalmysore Follow Jan 12 Building Interactive Data Visualizations in A2UI Angular: A Complete Guide # angular # javascript # tutorial # ui Comments Add Comment 4 min read Want to connect with vishalmysore? Create an account to connect with vishalmysore. You can also sign in below to proceed if you already have an account. Create Account Already have an account? Sign in Understanding the A2UI Protocol: Building with Java and Spring Boot vishalmysore vishalmysore vishalmysore Follow Jan 10 Understanding the A2UI Protocol: Building with Java and Spring Boot # ai # architecture # springboot # java Comments Add Comment 6 min read A2UI Protocol: Building Intelligent Agent-to-User Interfaces vishalmysore vishalmysore vishalmysore Follow Jan 10 A2UI Protocol: Building Intelligent Agent-to-User Interfaces # google # ai # agents # ui Comments Add Comment 6 min read The Orphan Axiom Problem in Ontology-Based RAG vishalmysore vishalmysore vishalmysore Follow Dec 18 '25 The Orphan Axiom Problem in Ontology-Based RAG # rag # llm # architecture # ai Comments Add Comment 6 min read Optimal Chunking for Ontology RAG: Empirical Analysis & Orphan Axiom Problem vishalmysore vishalmysore vishalmysore Follow Dec 18 '25 Optimal Chunking for Ontology RAG: Empirical Analysis & Orphan Axiom Problem # algorithms # rag # llm # ai Comments Add Comment 12 min read OWL-Aware Chunking Strategies: A Comprehensive Performance Analysis vishalmysore vishalmysore vishalmysore Follow Dec 18 '25 OWL-Aware Chunking Strategies: A Comprehensive Performance Analysis # algorithms # rag # performance # llm Comments Add Comment 12 min read Choosing the Right Chunking Strategy: A Comprehensive Guide to RAG Optimization vishalmysore vishalmysore vishalmysore Follow Dec 16 '25 Choosing the Right Chunking Strategy: A Comprehensive Guide to RAG Optimization # llm # performance # rag 8 reactions Comments Add Comment 10 min read RAG Chunking Strategies Deep Dive vishalmysore vishalmysore vishalmysore Follow Dec 13 '25 RAG Chunking Strategies Deep Dive # systemdesign # rag # ai # llm 1 reaction Comments Add Comment 7 min read Protégé to Neo4j GraphRAG: Transforming OWL Ontologies into AI-Ready, Powerful Knowledge Graphs vishalmysore vishalmysore vishalmysore Follow Dec 6 '25 Protégé to Neo4j GraphRAG: Transforming OWL Ontologies into AI-Ready, Powerful Knowledge Graphs Comments Add Comment 4 min read GraphRAG : From Zero to Hero vishalmysore vishalmysore vishalmysore Follow Dec 4 '25 GraphRAG : From Zero to Hero # rag # database # llm # tutorial Comments Add Comment 4 min read Neo4j GraphRAG: Intelligent Knowledge Graph Querying with AI vishalmysore vishalmysore vishalmysore Follow Dec 3 '25 Neo4j GraphRAG: Intelligent Knowledge Graph Querying with AI # ai # rag # database # llm Comments Add Comment 11 min read Neo4J Protege Plugin vishalmysore vishalmysore vishalmysore Follow Nov 29 '25 Neo4J Protege Plugin # showdev # database # ai # tooling Comments Add Comment 10 min read Fraud Detection with Knowledge Graphs: A Protégé and VidyaAstra Approach vishalmysore vishalmysore vishalmysore Follow Nov 23 '25 Fraud Detection with Knowledge Graphs: A Protégé and VidyaAstra Approach # cybersecurity # database # tutorial Comments Add Comment 16 min read Knowledge Graphs + LLM Integration: Query Your Ontology with Natural Language vishalmysore vishalmysore vishalmysore Follow Nov 23 '25 Knowledge Graphs + LLM Integration: Query Your Ontology with Natural Language # rag # llm # tooling # ai Comments Add Comment 4 min read Protege AI Plugin for Ontology Engineering vishalmysore vishalmysore vishalmysore Follow Nov 22 '25 Protege AI Plugin for Ontology Engineering # llm # ai # opensource # tooling Comments Add Comment 6 min read MCP Passthrough Server: A Superior Solution for Protocol Bridging vishalmysore vishalmysore vishalmysore Follow Sep 24 '25 MCP Passthrough Server: A Superior Solution for Protocol Bridging Comments Add Comment 5 min read What is Google AP2 Protocol : Step by Step Guide with Examples vishalmysore vishalmysore vishalmysore Follow Sep 18 '25 What is Google AP2 Protocol : Step by Step Guide with Examples # google # tutorial # ai # security 1 reaction Comments Add Comment 5 min read How to Give AI Coding Assistants Complete Context Across Microservices with BMAD FKS vishalmysore vishalmysore vishalmysore Follow Sep 16 '25 How to Give AI Coding Assistants Complete Context Across Microservices with BMAD FKS # ai # architecture # microservices Comments Add Comment 5 min read Agent As Code : BMAD-METHOD™ vishalmysore vishalmysore vishalmysore Follow Sep 10 '25 Agent As Code : BMAD-METHOD™ 1 reaction Comments Add Comment 2 min read RAG Evaluation in Java: A Comprehensive Guide vishalmysore vishalmysore vishalmysore Follow Sep 5 '25 RAG Evaluation in Java: A Comprehensive Guide Comments Add Comment 3 min read Build AI-Powered Microservices in Java Using Agent Communication Protocol (ACP) vishalmysore vishalmysore vishalmysore Follow Sep 1 '25 Build AI-Powered Microservices in Java Using Agent Communication Protocol (ACP) Comments Add Comment 3 min read Pure Java Implementation of Agent Communication Protocol vishalmysore vishalmysore vishalmysore Follow Aug 31 '25 Pure Java Implementation of Agent Communication Protocol Comments Add Comment 3 min read What is Agent Communication Protocol : Detailed Step by Step Guide vishalmysore vishalmysore vishalmysore Follow Aug 31 '25 What is Agent Communication Protocol : Detailed Step by Step Guide Comments Add Comment 8 min read A2A Client in Java: Bridging AI Agents with Java vishalmysore vishalmysore vishalmysore Follow Jun 21 '25 A2A Client in Java: Bridging AI Agents with Java Comments Add Comment 2 min read Online A2A Client with Java and WebSocket vishalmysore vishalmysore vishalmysore Follow Jun 19 '25 Online A2A Client with Java and WebSocket Comments Add Comment 1 min read Understanding A2A and Agent Cards vishalmysore vishalmysore vishalmysore Follow Jun 12 '25 Understanding A2A and Agent Cards 1 reaction Comments 1 comment 3 min read MCP Server and Agentic RAG Architecture: A RAG Killer in Disguise? vishalmysore vishalmysore vishalmysore Follow Jun 11 '25 MCP Server and Agentic RAG Architecture: A RAG Killer in Disguise? 1 reaction Comments Add Comment 3 min read MCP Apache Thrift Example: Polyglot AI Orchestration Platform vishalmysore vishalmysore vishalmysore Follow Jun 9 '25 MCP Apache Thrift Example: Polyglot AI Orchestration Platform Comments Add Comment 5 min read Building AI Agents with A2A and MCP Protocol: A Hands-on Implementation Guide vishalmysore vishalmysore vishalmysore Follow Jun 7 '25 Building AI Agents with A2A and MCP Protocol: A Hands-on Implementation Guide 1 reaction Comments 1 comment 14 min read Building an Agentic Mesh: A Practical Implementation with Multiple MCP Servers vishalmysore vishalmysore vishalmysore Follow Jun 6 '25 Building an Agentic Mesh: A Practical Implementation with Multiple MCP Servers 1 reaction Comments Add Comment 3 min read Building a Multi-Agent System with A2A and MCP Protocols in Java vishalmysore vishalmysore vishalmysore Follow Jun 5 '25 Building a Multi-Agent System with A2A and MCP Protocols in Java Comments Add Comment 3 min read MCP Server and Client in Java vishalmysore vishalmysore vishalmysore Follow Jun 4 '25 MCP Server and Client in Java Comments Add Comment 2 min read Build MCP server in Java with a2ajava vishalmysore vishalmysore vishalmysore Follow Jun 3 '25 Build MCP server in Java with a2ajava Comments 2 comments 2 min read Understanding Agentic Mesh: Patterns and Multi-Language Implementation vishalmysore vishalmysore vishalmysore Follow Jun 2 '25 Understanding Agentic Mesh: Patterns and Multi-Language Implementation Comments Add Comment 3 min read A2A vs MCP: A Comprehensive Protocol Comparison vishalmysore vishalmysore vishalmysore Follow Jun 1 '25 A2A vs MCP: A Comprehensive Protocol Comparison 1 reaction Comments Add Comment 3 min read Building AI Agents : A2A, MCP, Scala & Apache Spark vishalmysore vishalmysore vishalmysore Follow Jun 1 '25 Building AI Agents : A2A, MCP, Scala & Apache Spark 2 reactions Comments Add Comment 4 min read A2A + MCP Dual Protocol Server: A JVM-Based AI Revolution vishalmysore vishalmysore vishalmysore Follow May 31 '25 A2A + MCP Dual Protocol Server: A JVM-Based AI Revolution Comments Add Comment 3 min read A2A MCP Playwright For Web Automation vishalmysore vishalmysore vishalmysore Follow May 31 '25 A2A MCP Playwright For Web Automation Comments Add Comment 3 min read Building AI Agents in A2A and MCP: 5 Live Demos to Get You Started vishalmysore vishalmysore vishalmysore Follow May 28 '25 Building AI Agents in A2A and MCP: 5 Live Demos to Get You Started Comments Add Comment 3 min read Building Cross-Protocol AI Agents with Spring Boot: A2A and MCP Server Guide vishalmysore vishalmysore vishalmysore Follow May 28 '25 Building Cross-Protocol AI Agents with Spring Boot: A2A and MCP Server Guide 2 reactions Comments Add Comment 3 min read Selenium with A2A and MCP for AI Agents vishalmysore vishalmysore vishalmysore Follow May 27 '25 Selenium with A2A and MCP for AI Agents Comments Add Comment 2 min read A2A MCP RAG Application : Live Demo vishalmysore vishalmysore vishalmysore Follow May 25 '25 A2A MCP RAG Application : Live Demo 1 reaction Comments Add Comment 5 min read Securing the Agents: A2A & MCP with RBAC Access Control vishalmysore vishalmysore vishalmysore Follow May 24 '25 Securing the Agents: A2A & MCP with RBAC Access Control 1 reaction Comments Add Comment 3 min read Building a Multi-Protocol RAG System: Bridging A2A and MCP vishalmysore vishalmysore vishalmysore Follow May 21 '25 Building a Multi-Protocol RAG System: Bridging A2A and MCP 1 reaction Comments Add Comment 3 min read MCP Server in Java with a2ajava – The Swiss Knife for Agentic Applications vishalmysore vishalmysore vishalmysore Follow May 18 '25 MCP Server in Java with a2ajava – The Swiss Knife for Agentic Applications 2 reactions Comments Add Comment 3 min read Building Smart Agent-to-Agent (A2A) Applications with Kotlin vishalmysore vishalmysore vishalmysore Follow May 18 '25 Building Smart Agent-to-Agent (A2A) Applications with Kotlin Comments Add Comment 3 min read Google A2A RAG with Spring, Java, and MongoDB Atlas vishalmysore vishalmysore vishalmysore Follow May 15 '25 Google A2A RAG with Spring, Java, and MongoDB Atlas Comments Add Comment 2 min read Google A2A Protocol with Selenium: Revolutionizing Web Automation vishalmysore vishalmysore vishalmysore Follow May 11 '25 Google A2A Protocol with Selenium: Revolutionizing Web Automation Comments Add Comment 8 min read Google A2A Protocol : Kafka Messaging Agent vishalmysore vishalmysore vishalmysore Follow May 9 '25 Google A2A Protocol : Kafka Messaging Agent Comments Add Comment 5 min read Google A2A protocol : Log Monitoring Agent vishalmysore vishalmysore vishalmysore Follow May 9 '25 Google A2A protocol : Log Monitoring Agent Comments Add Comment 3 min read Google A2A Protocol : Integrating AI into existing Java Applications vishalmysore vishalmysore vishalmysore Follow May 8 '25 Google A2A Protocol : Integrating AI into existing Java Applications 2 reactions Comments Add Comment 4 min read A2A and MCP Protocols with Java and Spring vishalmysore vishalmysore vishalmysore Follow May 7 '25 A2A and MCP Protocols with Java and Spring 7 reactions Comments Add Comment 4 min read Java Meets AI: A2A & MCP—No Python Required vishalmysore vishalmysore vishalmysore Follow May 4 '25 Java Meets AI: A2A & MCP—No Python Required 2 reactions Comments Add Comment 3 min read Google A2A & Anthropic MCP: Harness Both to Build Powerful AI Applications vishalmysore vishalmysore vishalmysore Follow May 4 '25 Google A2A & Anthropic MCP: Harness Both to Build Powerful AI Applications Comments Add Comment 4 min read Google A2A Protocol: Building a Database Agent vishalmysore vishalmysore vishalmysore Follow May 1 '25 Google A2A Protocol: Building a Database Agent 4 reactions Comments 1 comment 5 min read MCP VS A2A : Similarities and Differences vishalmysore vishalmysore vishalmysore Follow Apr 27 '25 MCP VS A2A : Similarities and Differences Comments Add Comment 3 min read A2A Protocol : Deep Dive vishalmysore vishalmysore vishalmysore Follow Apr 26 '25 A2A Protocol : Deep Dive 1 reaction Comments Add Comment 3 min read Grok 2 with Java for Real-Time Tools Integration vishalmysore vishalmysore vishalmysore Follow Mar 25 '25 Grok 2 with Java for Real-Time Tools Integration Comments Add Comment 4 min read Bridging Java and AI Systems with Model Integration Protocol vishalmysore vishalmysore vishalmysore Follow Mar 23 '25 Bridging Java and AI Systems with Model Integration Protocol Comments Add Comment 3 min read Model Context Protocol Alternative: Spring And Java AI Tools Integration vishalmysore vishalmysore vishalmysore Follow Mar 23 '25 Model Context Protocol Alternative: Spring And Java AI Tools Integration Comments 1 comment 7 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://www.programiz.com/python-programming	Learn Python Programming 62 % OFF Get 66% off PRO Stop copy pasting code you don't actually understand Build the coding confidence you need to become a developer companies will fight for Stop copy pasting code you don't actually understand Ends in Become a PRO Become a PRO 62 % OFF Get 66% off PRO Stop copy pasting code you don't actually understand Build the coding confidence you need to become a developer companies will fight for Stop copy pasting code you don't actually understand Ends in Become a PRO Become a PRO Tutorials Examples Courses Try Programiz PRO Tutorials Courses Python JavaScript TypeScript SQL HTML CSS C C++ Java R Ruby RUST Golang Kotlin Swift C# DSA Become a certified Python programmer. ENROLL Popular Tutorials Getting Started With Python Python if Statement while Loop in Python Python Lists Dictionaries in Python Start Learning Python Popular Examples Add two numbers Check prime number Find the factorial of a number Print the Fibonacci sequence Check leap year Explore Python Examples Reference Materials Built-in Functions List Methods Dictionary Methods String Methods View all Created with over a decade of experience. Learn Practice Compete Learn Python Learn HTML Learn JavaScript Learn SQL Learn DSA Learn C Learn C++ Learn Java View all Courses on Python Basics Python Intermediate C++ Basics C++ Intermediate C++ OOP C Programming Java Basics Java Intermediate Java OOP View all Courses on Python Challenges JavaScript Challenges Java Challenges C++ Challenges C Challenges View all Challenges on Learn Practice Compete Certification Courses Created with over a decade of experience and thousands of feedback. Learn Python Learn HTML Learn JavaScript Learn SQL Learn DSA View all Courses on Learn C Learn C++ Learn Java Python JavaScript TypeScript SQL HTML CSS C C++ Java More languages Become a certified Python programmer. Try Programiz PRO! Popular Tutorials Getting Started With Python Python if Statement while Loop in Python Python Lists Dictionaries in Python Start Learning Python All Python Tutorials View all tutorials --> Reference Materials Built-in Functions List Methods Dictionary Methods String Methods View all Python JavaScript C C++ Java R Kotlin Become a certified Python programmer. Try Programiz PRO! Popular Examples Add two numbers Check prime number Find the factorial of a number Print the Fibonacci sequence Check leap year All Python Examples Learn Python Programming Tutorials Courses Examples References Online Compiler Recommended Course: Master Python Programming Perfect for beginners serious about building a career in Python. Created by the Programiz team with over a decade of experience. Try Now Enrollment: 317k Practice Problems: 239+ Projects: 5+ Certifications Python is one of the top programming languages in the world, widely used in fields such as AI, machine learning, data science, and web development. The simple and English-like syntax of Python makes it a go-to language for beginners who want to get into coding quickly. Because Python is used in multiple fields, there is a high demand for Python developers, with competitive base salaries. In this guide, we will cover: Beginner's Guide to Python Is Python for you? Best Way to Learn Python How to Run Python? If you are simply looking to learn Python step-by-step, you can follow our free tutorials in the next section. Beginner's Guide to Python These tutorials will provide you with a solid foundation in Python and prepare you for your career goals. Introduction How to Get Started With Python? Your First Python Program Python Comments Python Fundamentals Python Variables, Constants and Literals Python Type Conversion Python Basic Input and Output Python Operators Python Flow Control Python if...else Statement Python for Loop Python while Loop Python break and continue Python pass Statement Python Data Types Python Numbers, Type Conversion and Mathematics Python List Python Tuple Python Sets Python Dictionary Python Functions Python Functions Python Function Arguments Python Variable Scope Python Global Keyword Python Recursion Python Modules Python Package Python Main function Python Files Python Directory and Files Management Python CSV: Read and Write CSV files Reading CSV files in Python Writing CSV files in Python Python Exception Handling Python Exceptions Python Exception Handling Python Custom Exceptions Python Object and Class Python Objects and Classes Python Inheritance Python Multiple Inheritance Polymorphism in Python Python Operator Overloading Python Advanced Topics List comprehension Python Lambda/Anonymous Function Python Iterators Python Generators Python Namespace and Scope Python Closures Python Decorators Python @property decorator Python RegEx Python Date and Time Python datetime Python strftime() Python strptime() How to get current date and time in Python? Python Get Current Time Python timestamp to datetime and vice-versa Python time Module Python sleep() Additional Topic Precedence and Associativity of Operators in Python Python Keywords and Identifiers Python Asserts Python Json Python pip Python args and *kwargs Is Python for you? Whether Python is the right choice depends on what you want to accomplish and your career goals. Python from Learning Perspective If you are new to programming and prefer simplicity, Python is probably the right choice for you. Let's see an example. main.py x = 5 y = 10 print(x + y) main.c #include <stdio.h> int main() { int x = 5, y = 10; printf("%d", x + y); return 0; } Here, both programs in C and Python perform the same task. However, the Python code is much easier to understand, even if you have never been a programmer before. That being said, there are some advantages to learning languages like C as your first language. For example, C is much closer to the hardware and allows you to work with computer memory directly, thus providing you with a deeper understanding of how your code actually works. On the other hand, Python's clear, English-like syntax allows you to concentrate on problem-solving and building logic without being concerned about unnecessary complexities. So, it's up to you whether you want to quickly get started with programming or really take your time to understand the nitty-gritty parts of programming. Python as a Career Choice Python is a widely used programming language for creating real-world applications. It is extensively used in: Data Science Artificial Intelligence Automation Testing Backend Development Thus, learning Python offers significant advantages for your career opportunities. However, there are certain fields where Python doesn't excel. For example, if you are interested in frontend development, game development, or mobile app development, then Python is not the best choice. In these cases, alternatives such as JavaScript for frontend development, Kotlin, Swift, or Dart for mobile app development, and C++ for game development will be more suitable. Therefore, your career choices can guide you in selecting which programming language to learn. Best Way to Learn Python There is no right or wrong way to learn Python. It all depends on your learning style and pace. In this section, we have included the best Python learning resources tailored to your learning preferences, be it text-based, video-based, or interactive courses. Text-based Tutorial Best: if you are committed to learning Python but do not want to spend on it If you want to learn Python for free with a well-organized, step-by-step tutorial, you can use our free Python tutorials . Our tutorials will guide you through Python one step at a time, using practical examples to strengthen your foundation. Interactive Course Best: if you want hands-on learning, get your progress tracked, and maintain a learning streak Learning to code is tough. It requires dedication and consistency, and you need to write tons of code yourself. While videos and tutorials provide you with a step-by-step guide, they lack hands-on experience and structure. Recognizing all these challenges, Programiz offers a premium Learn Python Course that allows you to gain hands-on learning experience by solving challenges, building real-world projects, and tracking your progress. Online Video Best: if you are an audio-visual learner and learn by watching others code and following along If you're more of a visual learner, we have created a comprehensive Python course for beginners that will guide you on your Python journey. Additionally, there's a popular Python playlist by Corey Schafer available on YouTube to further guide you on your Python journey. If you're looking for a structured university course at zero cost, visit Python Course - University of Helsinki . Mobile App Best: if you are a casual and hobby learner who wants to learn Python on the go While it's possible to learn Python from mobile apps, it's not the ideal way because writing code can be challenging. Additionally, it's difficult to build real-world projects with multiple files on mobile devices. Nevertheless, you can use these apps to try things out. Learn Python Sololearn Important: You cannot learn to code without developing the habit of writing code yourself. Therefore, whatever method you choose, always write code. While writing code, you will encounter errors. Don't worry about them, try to understand them and find solutions. Remember, programming is all about solving problems, and errors are part of the process. How to Run Python? 1. Run Python in your browser. We have created an online editor to run Python directly in your browser. You don't have to go through a tedious installation process. It's completely free, and you can start coding directly. Run Python Online 2. Install Python on Your computer. Once you start writing complex programs and creating projects, you should definitely install Python on your computer. This is especially necessary when you are working with projects that involve multiple files and folders. To install Python on your device, you can use this guide. Getting Started with Python Learn how you can install and use Python on your own computer. Learn more Free Tutorials Python 3 Tutorials SQL Tutorials R Tutorials HTML Tutorials CSS Tutorials JavaScript Tutorials TypeScript Tutorials Java Tutorials C Tutorials C++ Tutorials DSA Tutorials C# Tutorials Golang Tutorials Kotlin Tutorials Swift Tutorials Rust Tutorials Ruby Tutorials Paid Courses Master Python Learn SQL Learn HTML FREE --> Master JavaScript Master C Master C++ Master Java Master DSA with Python Online Compilers Python Compiler R Compiler SQL Editor HTML/CSS Editor JavaScript Editor TypeScript Editor Java Compiler C Compiler C++ Compiler C# Compiler Go Compiler PHP Compiler Swift Compiler Rust Compiler Ruby Compiler Mobile Apps Learn Python App Learn C App Learn Java App Learn C++ App Company Change Ad Consent Do not sell my data About Contact Blog Youtube Careers Advertising Privacy Policy Terms & Conditions © Parewa Labs Pvt. Ltd. All rights reserved.	2026-01-13T08:49:46
https://dev.to/ben/meme-monday-2bg3	Meme Monday - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Ben Halpern Posted on Mar 17, 2025           Meme Monday # watercooler # discuss # jokes Meme Monday! Today's cover image comes from last week's thread . DEV is an inclusive space! Humor in poor taste will be downvoted by mods. Top comments (57) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Collapse Expand   Mr. Linxed Mr. Linxed Mr. Linxed Follow 👨‍💻 Professional problem solver - 🎧 Music lover Hello! Thanks for checking out my profile. If you haven't yet, make sure to also follow me on my other social media! ⬇️ Location The Netherlands Education The World Wide Web Work Professional Problem Solver Joined Sep 2, 2022 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 20  likes Like Comment button Reply Collapse Expand   Massimo Artizzu Massimo Artizzu Massimo Artizzu Follow Senior web developer 🔥 ~ conf speaker 🎙️ ~ loves science 🔭, art 🎨, rugby 🏉 ~ reinventing a better wheel 🎡 Location Italy Education Mathematics Work Consultant at Antreem Joined Jan 12, 2017 • Mar 17 '25 Dropdown menu Copy link Hide It could use localStorage for that setting, then. Like comment: Like comment: 4  likes Like Comment button Reply Collapse Expand   iDev-Games iDev-Games iDev-Games Follow I'm here for my open source projects, I also made a thing called iDev.Games as well Location UK Joined Mar 22, 2023 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 13  likes Like Comment button Reply Collapse Expand   Besworks Besworks Besworks Follow Web Component Evangelist ☕ ko-fi.com/besworks Location Canada Education The Internet Pronouns Guru Work Freelance Web Developer Joined Apr 3, 2022 • Mar 18 '25 Dropdown menu Copy link Hide ↗️↗️↗️ Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   iDev-Games iDev-Games iDev-Games Follow I'm here for my open source projects, I also made a thing called iDev.Games as well Location UK Joined Mar 22, 2023 • Mar 18 '25 Dropdown menu Copy link Hide Talking about that idea you've just had, here's a little Trig.js challange on dev.to! Something to distract you from your main project but hopefully not too much, you may even want to use Trig.js in your main project afterwards. Win win. 😏 Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   BernerT BernerT BernerT Follow Joined Jan 19, 2022 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 24  likes Like Comment button Reply Collapse Expand   Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Follow Ultra-fullstack software developer. Python, JavaScript, C#, C. Location Earth Education I am a master of science Pronouns He/him/his/his Work Software Engineer Joined May 2, 2017 • Mar 18 '25 • Edited on Mar 18 • Edited Dropdown menu Copy link Hide .house is a valid tld. this is yet another reason why you should not validate email addresses with regex 😋 Like comment: Like comment: 4  likes Like Comment button Reply Collapse Expand   𒎏Wii 🏳️‍⚧️ 𒎏Wii 🏳️‍⚧️ 𒎏Wii 🏳️‍⚧️ Follow Blog: https://blog.but.gay Mastodon: @darkwiiplayer@tech.lgbt Pronouns: en.pronouns.page/@darkwiiplayer Pronouns she/her;q=1, they/them;q=0.8, /;q=0.2 Joined Dec 4, 2018 • Mar 18 '25 Dropdown menu Copy link Hide There's a bunch of "new" TLDs that are longer than 4 characters, just saying. Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   Besworks Besworks Besworks Follow Web Component Evangelist ☕ ko-fi.com/besworks Location Canada Education The Internet Pronouns Guru Work Freelance Web Developer Joined Apr 3, 2022 • Mar 18 '25 Dropdown menu Copy link Hide Actually, per the spec , you don't even need a TLD for a valid email address. root@localhost is still valid, though only locally. For a signup form or something like that you definitely want to only allow valid internet email addresses. But technically, the domain can contain any number of dot-atom components. addr-spec = local-part "@" domain domain = dot-atom / domain-literal / obs-domain Enter fullscreen mode Exit fullscreen mode So me@my.long.ass.domain.name is just as valid as me@home . Also, domain-literal can be used so me@[192.168.1.1] is also valid but good luck every trying to create an account on a website with an address like that. Like comment: Like comment: 4  likes Like Thread Thread   Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Follow Ultra-fullstack software developer. Python, JavaScript, C#, C. Location Earth Education I am a master of science Pronouns He/him/his/his Work Software Engineer Joined May 2, 2017 • Mar 20 '25 • Edited on Mar 20 • Edited Dropdown menu Copy link Hide Also all parts of the address except the @ can contain comments. Don't forget the comments. ^[^@]+@[^@]+$ Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Reid Burton Reid Burton Reid Burton Follow I am an amateur programmer. I program in more languages than I care to remember. Location string Location = null; Education Homeschooled Pronouns He/Him Work Ceo of unemployment. Joined Nov 7, 2024 • Mar 27 '25 Dropdown menu Copy link Hide That's a broken regex. Errors: You cannot create a range with shorthand escape sequences Incomplete group structure Character class missing closing bracket Character range is out of order Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Ben Halpern Ben Halpern Ben Halpern Follow A Canadian software developer who thinks he’s funny. Email ben@forem.com Location NY Education Mount Allison University Pronouns He/him Work Co-founder at Forem Joined Dec 27, 2015 • Mar 17 '25 Dropdown menu Copy link Hide Let's kick this week off with our customary awful AI-generated meme Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   HB_the_Pencil HB_the_Pencil HB_the_Pencil Follow Just an average Christian bugtester and semi-game dev Joined Apr 19, 2023 • Mar 20 '25 Dropdown menu Copy link Hide Wow, that's higher quality than most of them... love how his eyes are pointing up into his face lol Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   plutonium239 plutonium239 plutonium239 Follow Education IIT Delhi Work ML Researcher Joined Jul 26, 2021 • Mar 21 '25 Dropdown menu Copy link Hide Average developer experience Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Best Codes Best Codes Best Codes Follow I love coding, 3D designing, and listening to music. I'm currently a fanatic about Rust, TypeScript, and Next.js. Christian, Coder, Creator Email bestcodes.official+devto@gmail.com Location Earth Education Self-taught Work Freelance Programmer \| Fullstack Dev Joined Oct 24, 2023 • Mar 17 '25 Dropdown menu Copy link Hide Using Gemini image outputs 🤪 Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Von Carter Griffen Von Carter Griffen Von Carter Griffen Follow Joined Jan 28, 2025 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 18  likes Like Comment button Reply Collapse Expand   keyr Syntax keyr Syntax keyr Syntax Follow I can speak the following languages: English, GOLANG, Typescript and JavaScript. Which languages do you speak? Location Addis Ababa, Ethiopia Joined Aug 10, 2024 • Mar 18 '25 Dropdown menu Copy link Hide What about 'git push --force --all'? Try it and thank me later 😁 Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Fraser Young Fraser Young Fraser Young Follow Joined Aug 29, 2023 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 22  likes Like Comment button Reply Collapse Expand   Besworks Besworks Besworks Follow Web Component Evangelist ☕ ko-fi.com/besworks Location Canada Education The Internet Pronouns Guru Work Freelance Web Developer Joined Apr 3, 2022 • Mar 19 '25 Dropdown menu Copy link Hide Like comment: Like comment: 5  likes Like Comment button Reply Collapse Expand   Massimo Artizzu Massimo Artizzu Massimo Artizzu Follow Senior web developer 🔥 ~ conf speaker 🎙️ ~ loves science 🔭, art 🎨, rugby 🏉 ~ reinventing a better wheel 🎡 Location Italy Education Mathematics Work Consultant at Antreem Joined Jan 12, 2017 • Mar 17 '25 Dropdown menu Copy link Hide I got most of my "Eureka!" moments on the latter. Like comment: Like comment: 8  likes Like Comment button Reply Collapse Expand   BBM BBM BBM Follow Curious developer Joined Aug 10, 2023 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 16  likes Like Comment button Reply Collapse Expand   Ivan Isaac Ivan Isaac Ivan Isaac Follow C# Dev Joined Jan 19, 2022 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 16  likes Like Comment button Reply Collapse Expand   𒎏Wii 🏳️‍⚧️ 𒎏Wii 🏳️‍⚧️ 𒎏Wii 🏳️‍⚧️ Follow Blog: https://blog.but.gay Mastodon: @darkwiiplayer@tech.lgbt Pronouns: en.pronouns.page/@darkwiiplayer Pronouns she/her;q=1, they/them;q=0.8, /;q=0.2 Joined Dec 4, 2018 • Mar 18 '25 Dropdown menu Copy link Hide The worst way to sit at a desk is sitting in the same posture for too long, regardless if it's "good posture" or "sitting like a shrimp". Move your spines, y'all! Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   Schemetastic (Rodrigo) Schemetastic (Rodrigo) Schemetastic (Rodrigo) Follow I started with JS about 10 years ago and I fell in love with it (even though it can be weird 😅). I had step backs in my career that ended up being good. Currently I'm a passionate front-end developer. Joined Sep 21, 2022 • Mar 17 '25 Dropdown menu Copy link Hide It's like the third time I watch this meme in the last 4 days, hahaha, always a good reminder. Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Besworks Besworks Besworks Follow Web Component Evangelist ☕ ko-fi.com/besworks Location Canada Education The Internet Pronouns Guru Work Freelance Web Developer Joined Apr 3, 2022 • Mar 18 '25 Dropdown menu Copy link Hide Yes! But also... Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Ben Sinclair Ben Sinclair Ben Sinclair Follow I've been a professional C, Perl, PHP and Python developer. I'm an ex-sysadmin from the late 20th century. These days I do more Javascript and CSS and whatnot, and promote UX and accessibility. Location Scotland Education Something something cybernetics Pronouns They/them Work General-purpose software person Joined Aug 29, 2017 • Mar 18 '25 Dropdown menu Copy link Hide Every time I see this I realise I'm sitting at my computer the equivalent of the way Marty McFly slept. Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Aaron Gibbs Aaron Gibbs Aaron Gibbs Follow Joined Nov 18, 2024 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 15  likes Like Comment button Reply Collapse Expand   Ryan Brown Ryan Brown Ryan Brown Follow He/Him; Senior Software Developer, IT Swiss-army-knife. Lots of coding, some hardware, some devops & sysops, some micro-controller electronics. I used Arch BTW :) Location Canada Education Computer Systems Technology Deploma Pronouns he/him Work Senior Software Developer Joined Jan 13, 2017 • Mar 18 '25 Dropdown menu Copy link Hide Sunday being week[0] and Monday being week[1] is how I explain Zero-Index arrays to normies :D Like comment: Like comment: 4  likes Like Comment button Reply Collapse Expand   𒎏Wii 🏳️‍⚧️ 𒎏Wii 🏳️‍⚧️ 𒎏Wii 🏳️‍⚧️ Follow Blog: https://blog.but.gay Mastodon: @darkwiiplayer@tech.lgbt Pronouns: en.pronouns.page/@darkwiiplayer Pronouns she/her;q=1, they/them;q=0.8, /;q=0.2 Joined Dec 4, 2018 • Mar 18 '25 Dropdown menu Copy link Hide No, starting on Sunday is like starting at [-1] Like comment: Like comment: 4  likes Like Comment button Reply Collapse Expand   Dream Dream Dream Follow Joined Jan 19, 2022 • Mar 17 '25 Dropdown menu Copy link Hide Like comment: Like comment: 14  likes Like Comment button Reply View full discussion (57 comments) Some comments may only be visible to logged-in visitors. Sign in to view all comments. Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse Ben Halpern Follow A Canadian software developer who thinks he’s funny. Location NY Education Mount Allison University Pronouns He/him Work Co-founder at Forem Joined Dec 27, 2015 More from Ben Halpern Meme Monday # discuss # watercooler # jokes Meme Monday # discuss # jokes # watercooler Meme Monday # discuss # watercooler # jokes 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV Forem — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . Forem © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://www.algolia.com/fr/products/intelligent-data-kit	Intelligent Data Kit Niket --> Deutsch English français News DevCon2025 \| October 1-2 Learn more Algolia Partners Support Login Logout Algolia mark white Algolia logo white Products Search Show users what they're looking for with AI-driven resuts. Search Show users what they're looking for with AI-driven resuts. Recommendations Use behavioral cues to drive higher engagement. Recommendations Use behavioral cues to drive higher engagement. Personalization Show each user what they need across their journey. Personalization Show each user what they need across their journey. Analytics All your insights in one dashboard. Analytics All your insights in one dashboard. Browse Move customers down the funnel with curated category pages. Browse Move customers down the funnel with curated category pages. Agent Studio Create, test, and deploy AI agents, fast. Agent Studio Create, test, and deploy AI agents, fast. Generative Experiences Build conversational solutions with retrieval augmented generation (RAG). Generative Experiences Build conversational solutions with retrieval augmented generation (RAG). Ask AI Deliver conversational answers—right from your search bar. Ask AI Deliver conversational answers—right from your search bar. MCP Server Search, analyze, or monitor your index within your agentic workflow. MCP Server Search, analyze, or monitor your index within your agentic workflow. Data Enrichment Modify, enhance, or restructure data as it’s indexed for search. Data Enrichment Modify, enhance, or restructure data as it’s indexed for search. Data Transformation Streamline data preparation and enhance data quality. Data Transformation Streamline data preparation and enhance data quality. Integrations Connect to your existing stack via pre-built libraries and APIs. Integrations Connect to your existing stack via pre-built libraries and APIs. Data Centers Choose from 70+ data centers across 17 regions. Data Centers Choose from 70+ data centers across 17 regions. Security & Compliance Built for peace of mind. Security & Compliance Built for peace of mind. Industries Ecommerce Ecommerce B2B Commerce B2B Commerce Fashion Fashion Grocery Grocery Media Media Marketplaces Marketplaces SaaS SaaS Higher Education Higher Education Documentation search Documentation search Enterprise search Enterprise search Headless commerce Headless commerce Image search Image search Mobile & App search Mobile & App search Retail Media Network Retail Media Network Site search Site search Visual search Visual search Voice search Voice search Digital Experience Digital Experience Ecommerce Ecommerce Engineering Engineering Merchandising Merchandising Product Management Product Management Tarifs Développeurs GET STARTED Developer Hub Developer Hub Documentation Documentation Intégrations Intégrations Composants UI Composants UI Auto-completion Auto-completion RESOURCES Code Exchange Code Exchange Engineering Blog Engineering Blog MCP MCP Discord Discord Webinars & Events Webinars & Events QUICK LINKS Démarrage rapide Démarrage rapide Pour Open Source Pour Open Source Statuts d'API Statuts d'API Support Support Resources INSPIRATION Algolia Blog Algolia Blog Resource Center Resource Center Témoignages clients Témoignages clients Webinars & Events Webinars & Events Newsroom Newsroom LEARN Customer Hub Customer Hub What's New What's New AI Search Grader AI Search Grader Documentation Documentation Évènements Évènements Professional Services Professional Services Quick Access Algolia Partners Support Login Logout Request demo Get started Search Algolia Close Request demo Get started Other Types Filter --> Clear All Filters Filters Looking for our logo? We got you covered! Brand guidelines Download logo pack Intelligent Data Kit Des données plus intelligentes. Un processus simplifié. Plus de possibilités. Transformez, enrichissez et préparez vos données, en toute simplicité, grâce à notre kit intégré. Découvrez l’Intelligent Data Kit Des données désordonnées et cloisonnées figurent parmi les principaux freins à une recherche et une personnalisation de qualité. L’ Intelligent Data Kit résout ce problème en mettant des outils intuitifs et des recommandations basées sur l’IA à la disposition de toutes les équipes — pas seulement des data engineers. Transformation des données Remodelez vos données : nettoyez les champs inutiles, créez des attributs dynamiques, calculez des classements personnalisés, et plus encore. Les profils techniques peuvent travailler directement en code. Les non-techniciens disposent d’une interface no-code simple d’utilisation.   En savoir plus Enrichissez vos données Algolia Fetch vous permet de connecter des sources externes via API et de récupérer automatiquement les données pour garder un index toujours à jour. En savoir plus Intégrations fluides Connectez-vous à votre stack existante grâce à des connecteurs no-code. Importez des données en temps réel depuis des APIs comme DeepL , Stripe ou Google Maps pour enrichir vos résultats de recherche. En savoir plus Exemples d’usages de l’Intelligent Data Kit Mettre en avant automatiquement les promotions Taguer des produits pour des campagnes saisonnières Exclure les données inutiles ou de test des résultats de recherche Créer des catégories de tailles à partir de données brutes Déduire des valeurs de remise manquantes Enrichir les enregistrements avec des données externes en temps réel --> Avantages en un coup d’œil Que vous soyez merchandiser, content manager ou développeur, vous pouvez désormais nettoyer, enrichir et activer vos données, plus rapidement que jamais. Augmentez la pertinence de la recherche et la personnalisation Des données propres et enrichies améliorent le scoring de pertinence, offrant des résultats plus précis et des expériences sur mesure dans la recherche, les recommandations et le merchandising. Accélérez le time-to-value L’Intelligent Data Kit élimine les tâches de nettoyage répétitives, réduit la surcharge d’index et simplifie l’intégration avec des APIs externes. Renforcez la transparence et la confiance Visualisez comment les données sont transformées, enrichies et utilisées, renforçant la confiance entre les équipes et facilitant la conformité avec vos standards internes. Réduisez les blocages côté développement Grâce à des outils no-code intuitifs et des transformations guidées par l’IA, les équipes métier peuvent agir directement — accélérant les expérimentations, le lancement de campagnes et l’itération produit. FAQ – Intelligent Data Kit Qu’est-ce que l’Intelligent Data Kit ? 0 C’est une suite d’outils Algolia qui vous aide à nettoyer, enrichir et connecter vos données — afin de débloquer de meilleures expériences de recherche, d’analyse et digitales, sans lourdes charges de développement. À qui s’adresse l’Intelligent Data Kit ? 0 Le kit est conçu pour les profils techniques et non techniques. Les équipes métier peuvent effectuer des changements via une interface visuelle, tandis que les développeurs bénéficient d’intégrations robustes et d’une réduction de la charge de maintenance. Dois-je savoir coder pour l’utiliser ? 0 Non. Vous pouvez utiliser des prompts en langage naturel ou des contrôles par glisser-déposer pour exécuter des transformations complexes. Les développeurs peuvent aussi se connecter aux APIs ou pipelines avancés si nécessaire. Quels types de données puis-je nettoyer ou transformer ? 0 Tout type de données : catalogues produits, métadonnées de contenu, logs de comportement utilisateur… Les cas d’usage fréquents incluent le tagging de produits saisonniers, la suppression de données test/inutiles, le calcul de classements ou la structuration de filtres (par prix, tailles, etc.). Comment cela améliore-t-il mon expérience de recherche Algolia ? 0 Des données plus propres et enrichies donnent des résultats de recherche plus pertinents et plus personnalisés. Vous pouvez aussi réduire le bruit dans vos index, améliorer les performances et mieux contrôler le classement et le filtrage des items. Puis-je le connecter à des APIs ou outils externes ? 0 Oui. La fonctionnalité Fetch permet d’enrichir vos enregistrements avec des données en temps réel issues de sources tierces comme DeepL , Google Maps ou Stripe , directement dans votre pipeline de transformation Algolia. Est-ce inclus dans mon plan actuel ? 0 L’Intelligent Data Kit est déjà disponible. Contactez votre représentant Algolia pour vérifier la compatibilité avec votre plan et votre niveau de tarification. Créez les meilleures expériences de recherche et de navigation Obtenir une démo Commencez gratuitement Solutions Aperçu AI Search AI Browse AI Recommendations Ask AI Intelligent Data Kit Cas d'usage Aperçu Recherche Enterprise Ecommerce headless Recherche mobile Recherche vocale Recherche d'image OEM Recherche d'image Développeurs Developer Hub Documentation Intégrations Engineering blog Communauté Discord Status d'API DocSearch Pour Open Source Demos GDPR AI Act Intégrations Salesforce Commerce Cloud B2C Shopify Adobe Commerce Netlify Commercetools BigCommerce Distribué & sécurisé Infrastructure mondiale Sécurité & conformité Azure AWS Industries Aperçu Ecommerce B2C Ecommerce B2B Marketplaces SaaS Média Startups Fashion Tools Search Grader Ecommerce Search Audit Algolia À propos Carrières Newsroom Évènements Équipe dirigeante Impact social Contact us Anti-Modern Slavery Statement Awards Réseaux sociaux Développeurs Developer Hub Documentation Intégrations Engineering blog Communauté Discord Status d'API DocSearch Pour Open Source Demos GDPR AI Act Industries Aperçu Ecommerce B2C Ecommerce B2B Marketplaces SaaS Média Startups Fashion Tools Search Grader Ecommerce Search Audit Solutions Aperçu AI Search AI Browse AI Recommendations Ask AI Intelligent Data Kit Cas d'usage Aperçu Recherche Enterprise Ecommerce headless Recherche mobile Recherche vocale Recherche d'image OEM Recherche d'image Intégrations Salesforce Commerce Cloud B2C Shopify Adobe Commerce Netlify Commercetools BigCommerce Distribué & sécurisé Infrastructure mondiale Sécurité & conformité Azure AWS Algolia À propos Carrières Newsroom Évènements Équipe dirigeante Impact social Contact us Anti-Modern Slavery Statement Awards Réseaux sociaux Algolia mark white ©2026 Algolia - All rights reserved. Cookie settings Trust Center Politique de confidentialité Conditions d'utilisation Politique d'utilisation acceptable	2026-01-13T08:49:46
https://opensource.org/license/artistic-1-0	Artistic License 1.0 – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Superseded Artistic License 1.0 Version 1.0 SPDX short identifier: Artistic-1.0 (NOTE: This license has been superseded by the Artistic License, Version 2.0 .) Some versions of the artistic license contain the following clause: 8.Aggregation of this Package with a commercial distribution is always permitted provided that the use of this Package is embedded; that is, when no overt attempt is made to make this Package’s interfaces visible to the end user of the commercial distribution. Such use shall not be construed as a distribution of this Package. With this clause present, it is called the Artistic License (Perl) 1.0 (abbreviated as Artistic-Perl-1.0 . With or without this clause, the license is approved by OSI for certifying software as OSI Certified Open Source. One such example is the Artistic License (Perl) 1.0 . The Artistic License Preamble The intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications. Definitions: "Package" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification. "Standard Version" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder. "Copyright Holder" is whoever is named in the copyright or copyrights for the package. "You" is you, if you're thinking about copying or distributing this Package. "Reasonable copying fee" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.) "Freely Available" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it. 1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers. 2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version. 3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following: a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as ftp.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package. b) use the modified Package only within your corporation or organization. c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version. d) make other distribution arrangements with the Copyright Holder. 4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following: a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version. b) accompany the distribution with the machine-readable source of the Package with your modifications. c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version. d) make other distribution arrangements with the Copyright Holder. 5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own. 6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package. 7. C or perl subroutines supplied by you and linked into this Package shall not be considered part of this Package. 8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission. 9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End Donate to the OSI The OSI is the authority that defines Open Source, recognized globally by individuals, companies, and public institutions. The Open Source Initiative (OSI) is a 501(c)3 public benefit corporation, founded in 1998. --> Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://id-id.facebook.com/login/?next=https%3A%2F%2Fwww.facebook.com%2Fshare_channel%2F%3Ftype%3Dreshare%26link%3Dhttps%253A%252F%252Fdev.to%252Ftatyanabayramova%252Fglaucoma-awareness-month-363o%26app_id%3D966242223397117%26source_surface%3Dexternal_reshare%26display%26hashtag	Masuk Facebook Notice Anda harus login untuk melanjutkan. Login ke Facebook Anda harus login untuk melanjutkan. Masuk Lupa akun? atau Buat akun baru Bahasa Indonesia 한국어 English (US) Tiếng Việt ภาษาไทย Español 中文(简体) 日本語 Português (Brasil) Français (France) Deutsch Daftar Masuk Messenger Facebook Lite Video Meta Pay Meta Store Meta Quest Ray-Ban Meta Meta AI Konten Meta AI lainnya Instagram Threads Pusat Informasi Pemilu Kebijakan Privasi Pusat Privasi Tentang Buat Iklan Buat Halaman Developer Karier Cookie Pilihan Iklan Ketentuan Bantuan Pengunggahan Kontak & Non-Pengguna Pengaturan Log aktivitas Meta © 2026	2026-01-13T08:49:46
https://jsfiddle.net/cdn-cgi/content?id=L8BRu0lo2m6srzV1PgjPQKmA3mLDVGRVk0ISq9YCmxU-1768294134.303293-1.0.1.1-b9pA.jJkggS2Cc3t8myy3uFqTgqYlIRF1B1fXyYDA9E	Computational Complexity Theory: Unveiling the Mysteries of Algorithmic Efficiency Introduction to Computational Complexity Theory Computational complexity theory is a fascinating field that delves into the study of resources required to solve computational problems. It provides a framework for analyzing the efficiency of algorithms, which is crucial in today's world where computing power and data storage are increasingly important. At its core, computational complexity theory aims to understand the inherent difficulties of solving problems and the limitations of efficient computation. The Basics of Computational Complexity In essence, computational complexity theory is concerned with the amount of time and space an algorithm requires to solve a problem. The time complexity of an algorithm refers to the number of steps it takes to complete, while the space complexity refers to the amount of memory it uses. These two measures are fundamental in understanding the efficiency of an algorithm and are often expressed using Big O notation, which gives an upper bound on the number of steps or space required. P and NP: The Fundamental Classes Two of the most significant classes in computational complexity theory are P (short for Polynomial Time) and NP (short for Nondeterministic Polynomial Time). P consists of decision problems that can be solved in polynomial time by a deterministic Turing machine, meaning the running time increases at most polynomially with the size of the input. On the other hand, NP includes decision problems where a proposed solution can be verified in polynomial time by a deterministic Turing machine, but the solution itself may not be found quickly. The P vs. NP Problem One of the most profound open questions in computer science is whether P equals NP. If P=NP, then every problem with a known efficient algorithm for verification also has an efficient algorithm for finding a solution. However, if P≠NP, then there exist problems for which no efficient algorithm exists, even if a solution can be efficiently verified. The resolution of this question has significant implications for cryptography, optimization problems, and many areas of science and engineering. Reductions and NP-Completeness A key concept in demonstrating the hardness of problems is reduction, where one problem is transformed into another. If a problem A can be reduced to problem B, and B is known to be hard, then A is at least as hard as B. NP-complete problems are those in NP that are at least as hard as the hardest problems in NP. If any NP-complete problem is found to have a polynomial-time solution, then P=NP. Examples of NP-complete problems include the traveling salesman problem, Boolean satisfiability problem (SAT), and the knapsack problem. Conclusion In conclusion, computational complexity theory offers a rich framework for understanding the intricacies of algorithmic efficiency and the limits of computation. Through the lens of P, NP, and reductions, we gain insight into the fundamental challenges of solving complex problems efficiently. As computing continues to play an ever-increasing role in our lives, the study of computational complexity theory remains vital, guiding us towards more efficient solutions and illuminating the boundaries of what can be computed.	2026-01-13T08:49:46
https://www.algolia.com/fr/use-cases/headless-commerce	La recherche et navigation Algolia pour e-commerce headless Niket --> Deutsch English français News DevCon2025 \| October 1-2 Learn more Algolia Partners Support Login Logout Algolia mark white Algolia logo white Products Search Show users what they're looking for with AI-driven resuts. Search Show users what they're looking for with AI-driven resuts. Recommendations Use behavioral cues to drive higher engagement. Recommendations Use behavioral cues to drive higher engagement. Personalization Show each user what they need across their journey. Personalization Show each user what they need across their journey. Analytics All your insights in one dashboard. Analytics All your insights in one dashboard. Browse Move customers down the funnel with curated category pages. Browse Move customers down the funnel with curated category pages. Agent Studio Create, test, and deploy AI agents, fast. Agent Studio Create, test, and deploy AI agents, fast. Generative Experiences Build conversational solutions with retrieval augmented generation (RAG). Generative Experiences Build conversational solutions with retrieval augmented generation (RAG). Ask AI Deliver conversational answers—right from your search bar. Ask AI Deliver conversational answers—right from your search bar. MCP Server Search, analyze, or monitor your index within your agentic workflow. MCP Server Search, analyze, or monitor your index within your agentic workflow. Data Enrichment Modify, enhance, or restructure data as it’s indexed for search. Data Enrichment Modify, enhance, or restructure data as it’s indexed for search. Data Transformation Streamline data preparation and enhance data quality. Data Transformation Streamline data preparation and enhance data quality. Integrations Connect to your existing stack via pre-built libraries and APIs. Integrations Connect to your existing stack via pre-built libraries and APIs. Data Centers Choose from 70+ data centers across 17 regions. Data Centers Choose from 70+ data centers across 17 regions. Security & Compliance Built for peace of mind. Security & Compliance Built for peace of mind. Industries Ecommerce Ecommerce B2B Commerce B2B Commerce Fashion Fashion Grocery Grocery Media Media Marketplaces Marketplaces SaaS SaaS Higher Education Higher Education Documentation search Documentation search Enterprise search Enterprise search Headless commerce Headless commerce Image search Image search Mobile & App search Mobile & App search Retail Media Network Retail Media Network Site search Site search Visual search Visual search Voice search Voice search Digital Experience Digital Experience Ecommerce Ecommerce Engineering Engineering Merchandising Merchandising Product Management Product Management Tarifs Développeurs GET STARTED Developer Hub Developer Hub Documentation Documentation Intégrations Intégrations Composants UI Composants UI Auto-completion Auto-completion RESOURCES Code Exchange Code Exchange Engineering Blog Engineering Blog MCP MCP Discord Discord Webinars & Events Webinars & Events QUICK LINKS Démarrage rapide Démarrage rapide Pour Open Source Pour Open Source Statuts d'API Statuts d'API Support Support Resources INSPIRATION Algolia Blog Algolia Blog Resource Center Resource Center Témoignages clients Témoignages clients Webinars & Events Webinars & Events Newsroom Newsroom LEARN Customer Hub Customer Hub What's New What's New AI Search Grader AI Search Grader Documentation Documentation Évènements Évènements Professional Services Professional Services Quick Access Algolia Partners Support Login Logout Request demo Get started Search Algolia Close Request demo Get started Other Types Filter --> Clear All Filters Filters Looking for our logo? We got you covered! Brand guidelines Download logo pack Recherche e-commerce headless Créez une expérience de recherche et de découverte pour votre e-commerce headless. Offrez des expériences riches, basées sur les produits et le contenu, dans un cadre e-commerce headless, sur tous vos appareils et canaux. Demander une démo Commencer gratuitement ]:border-l md:[&>:nth-child(1)]:border-none md:[&>*:nth-child(4n+1)]:border-none"> 1,7+ trillion de recherches chaque année 99,999 % de disponibilité SLA possible 382 % de ROI selon Forrester Research 18 000+ clients dans plus de 150 pays Démarrez votre parcours headless avec une expérience de recherche améliorée E-commerce headless sur tous les canaux Notre plateforme de search-as-a-service s’intègre à votre site e-commerce traditionnel, application monopage (SPA), application web progressive (PWA), application mobile, borne en magasin, application métier et plus encore, le tout à partir d’une plateforme unifiée. Notre plateforme API-first est accompagnée de bibliothèques front-end pour de nombreux frameworks populaires. Éliminez vos silos de données Indexez toutes vos informations produits, ainsi que votre contenu éditorial et d’assistance. Notre plateforme de recherche inclut un crawler avancé, une intégration avec les principales plateformes e-commerce, et des clients API dans 11 langages. Peu importe le système back-end qui héberge vos données produits et contenus, nous pouvons les indexer et les restituer dans n’importe quelle expérience front-end. Voir nos intégrations Offrez de véritables expériences personnalisées et omnicanales Mettez en place une stratégie de personnalisation unifiée sur tous vos points de contact clients. Une seule plateforme de recherche omnicanale et un moteur de personnalisation IA garantissent une expérience utilisateur cohérente et personnalisée. À mesure que vos visiteurs interagissent avec votre marque, Algolia apprend leurs préférences et ajuste l’expérience en conséquence, rendant chaque interaction plus enrichissante. Développez et itérez 10 fois plus vite L’approche API-first d’Algolia vous permet d’expérimenter facilement de nouvelles expériences et interfaces sans avoir besoin de développer côté back-end. Flexibilité front-end pour une expérience optimale Notre implémentation front-end est totalement flexible, vous permettant de créer l’expérience la plus adaptée à vos besoins et à votre image de marque. Nous offrons des algorithmes de classement et de personnalisation transparents et entièrement personnalisables. Essayez dès maintenant Améliorez l’agilité métier avec un merchandising centralisé En pilotant toutes les expériences utilisateurs depuis une plateforme unique, vos équipes métier peuvent exploiter des outils de gestion de recherche pour optimiser efficacement votre vitrine en ligne. Découvrez le Merchandising Studio Adoptez l’API-first dans votre architecture headless Algolia s’inscrit dans un écosystème de solutions e-commerce de pointe. Que vous appeliez votre plateforme headless commerce , composable commerce , architecture microservices , Jamstack , MACH ou serverless , notre approche API-first s’intègre parfaitement. Recommended content Merchandising in the era of artificial intelligence (AI) The advent of AI heralds a revolutionary opportunity that will change how merchandisers operate & strategize, but ecommerce businesses will face new challenges as they integrate AI-powered technology. Read more An introduction to data-driven AI merchandising Your homepage is the window into your store. But how do merchandisers maximize the power of their online real estate to drive sales, brand experiences, and other critical outcomes? Read more Zeeman improves Search performance & gives customers a 'remarkably simple' experience Zeeman deployed Algolia in record time and hasn’t looked back, iterating, and improving on Search to the benefit of its customers, its e-commerce and merchandising teams — and its revenue. Read more See more FAQ sur la solution e-commerce headless Avec quelles plateformes e-commerce headless Algolia est-elle compatible ? 0 La solution API-first d’Algolia est compatible avec toutes les plateformes e-commerce headless. Nous proposons également une intégration native avec Salesforce Commerce Cloud , Magento et Shopify. Si j’intègre Algolia à mon e-commerce headless, fournissez-vous des composants front-end ? 0 Oui. Vous pouvez créer votre propre front-end en utilisant nos composants InstantSearch , ainsi que nos guides pour construire des versions avancées. Vous pouvez aussi partir d’un modèle préconstruit de recherche et découverte e-commerce. Quel est le coût d’Algolia pour une plateforme e-commerce headless ? 0 Vous pouvez commencer avec un essai gratuit et découvrir comment cela fonctionne pour vous. Ensuite, notre grille tarifaire compétitive s’applique. Proposez-vous des services pour passer à une approche e-commerce headless ? 0 Non, mais nous travaillons avec des partenaires qui aident les distributeurs à passer au e-commerce headless. En savoir plus. Un autre modèle courant d’application mobile, permettant d’optimiser l’espace limité d’un petit écran lors d’une recherche, est la recherche à facettes . Elle permet à l’utilisateur d’affiner ses résultats en appliquant des filtres, généralement en sélectionnant des options présentées dans une interface de type « tiroir ». La recherche à facettes est fréquemment utilisée par les détaillants en e-commerce (et son équivalent mobile, le m-commerce), ainsi que par les prestataires de services de voyage et les sites médias proposant des outils de recherche en ligne. Une application relativement récente de la recherche sur mobile est la recherche vocale . Selon eMarketer, en 2019, 40 % des internautes américains utilisaient la recherche vocale, une pratique qui gagne en popularité, bien que progressivement. Try the AI search that understands Get a demo Start Free Solutions Aperçu AI Search AI Browse AI Recommendations Ask AI Intelligent Data Kit Cas d'usage Aperçu Recherche Enterprise Ecommerce headless Recherche mobile Recherche vocale Recherche d'image OEM Recherche d'image Développeurs Developer Hub Documentation Intégrations Engineering blog Communauté Discord Status d'API DocSearch Pour Open Source Demos GDPR AI Act Intégrations Salesforce Commerce Cloud B2C Shopify Adobe Commerce Netlify Commercetools BigCommerce Distribué & sécurisé Infrastructure mondiale Sécurité & conformité Azure AWS Industries Aperçu Ecommerce B2C Ecommerce B2B Marketplaces SaaS Média Startups Fashion Tools Search Grader Ecommerce Search Audit Algolia À propos Carrières Newsroom Évènements Équipe dirigeante Impact social Contact us Anti-Modern Slavery Statement Awards Réseaux sociaux Développeurs Developer Hub Documentation Intégrations Engineering blog Communauté Discord Status d'API DocSearch Pour Open Source Demos GDPR AI Act Industries Aperçu Ecommerce B2C Ecommerce B2B Marketplaces SaaS Média Startups Fashion Tools Search Grader Ecommerce Search Audit Solutions Aperçu AI Search AI Browse AI Recommendations Ask AI Intelligent Data Kit Cas d'usage Aperçu Recherche Enterprise Ecommerce headless Recherche mobile Recherche vocale Recherche d'image OEM Recherche d'image Intégrations Salesforce Commerce Cloud B2C Shopify Adobe Commerce Netlify Commercetools BigCommerce Distribué & sécurisé Infrastructure mondiale Sécurité & conformité Azure AWS Algolia À propos Carrières Newsroom Évènements Équipe dirigeante Impact social Contact us Anti-Modern Slavery Statement Awards Réseaux sociaux Algolia mark white ©2026 Algolia - All rights reserved. Cookie settings Trust Center Politique de confidentialité Conditions d'utilisation Politique d'utilisation acceptable	2026-01-13T08:49:46
https://opensource.org/license/bsd-3-clause-open-mpi	BSD-3-Clause-Open-MPI – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Other/Miscellaneous BSD-3-Clause-Open-MPI Submitted: May 20, 2025 Submitter: McCoy Smith Approved: July 18, 2025 Board minutes SPDX short identifier: BSD-3-Clause-Open-MPI Steward: Open MPI Link to license steward's version Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer listed in this license in the documentation and/or other materials provided with the distribution. Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. The copyright holders provide no reassurances that the source code provided does not infringe any patent, copyright, or any other intellectual property rights of third parties. The copyright holders disclaim any liability to any recipient for claims brought against recipient by any third party for infringement of that parties intellectual property rights. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Donate to the OSI The OSI is the authority that defines Open Source, recognized globally by individuals, companies, and public institutions. The Open Source Initiative (OSI) is a 501(c)3 public benefit corporation, founded in 1998. --> Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://go.opensource.org/cisco	Open Source at Cisco - Open Source at Cisco Projects Compliance Blog GitHub Projects Compliance Blog GitHub Menu Open Source at Cisco Explore community-powered innovation in cloud native development, AI/ML, API security, observability, network automation, and more, with contributions from Cisco developers. Featured projects AGNTCY The AGNTCY is an open source collective building the infrastructure for The Internet of Agents: an open, interoperable internet for agent to agent collaboration. Bank-Vaults An umbrella project that provides various tools for Vault to make using Hashicorp Vault easier, including a wrapper for the official Vault client. Calico-VPP Integration of VPP, a fast userspace networking stack, as a dataplane for Calico. ClamAV An open source antivirus engine for detecting trojans, viruses, malware & other malicious threats. Cilium eBPF-based Networking, Observability, Security--Cilium is an open source, cloud native solution for providing, securing, and observing network connectivity between workloads, fueled by the revolutionary Kernel technology eBPF. eBPF An ecosystem around the Linux kernel capability to run sandboxed programs to safely and efficiently extend the capabilities of the kernel without requiring to change kernel source code or load kernel modules. The eBPF communities implement kernel technology, SDKs, and user space projects to dynamically program the kernel for efficient networking, observability, tracing, and security. Fast Data Project Relentlessly focused on data IO speed and efficiency for more flexible and scalable networks and storage. Snort It is an open source intrusion prevention system capable of real-time traffic analysis and packet logging. Tetragon eBPF-based Security Observability and Runtime Enforcement--Tetragon is a flexible Kubernetes-aware security observability and runtime enforcement tool that applies policy and filtering directly with eBPF, allowing for reduced observation overhead, tracking of any process, and real-time enforcement of policies. Where we contribute Cisco proudly sponsors Welcome to Open Source at Cisco! Check out our favorite projects from the open source community. Cisco developers contribute to these initiatives, and we use these projects in our platforms and solutions. Stay tuned for more... we're excited to collaborate with you further! Cisco OSPO Company cisco.com Outshift Research Innovation Labs Who We Are Careers Info Feedback Help Terms & Conditions Privacy Statement Cookies Trademarks Product Open Source Notices Supply Chain Transparency Sitemap © 2023 Cisco Systems, Inc.	2026-01-13T08:49:46
https://github.com/mitul3737	mitul3737 (Md Shahriyar Al Mustakim Mitul) · GitHub Skip to content Navigation Menu Toggle navigation Sign in Appearance settings Platform AI CODE CREATION GitHub Copilot Write better code with AI GitHub Spark Build and deploy intelligent apps GitHub Models Manage and compare prompts MCP Registry New Integrate external tools DEVELOPER WORKFLOWS Actions Automate any workflow Codespaces Instant dev environments Issues Plan and track work Code Review Manage code changes APPLICATION SECURITY GitHub Advanced Security Find and fix vulnerabilities Code security Secure your code as you build Secret protection Stop leaks before they start EXPLORE Why GitHub Documentation Blog Changelog Marketplace View all features Solutions BY COMPANY SIZE Enterprises Small and medium teams Startups Nonprofits BY USE CASE App Modernization DevSecOps DevOps CI/CD View all use cases BY INDUSTRY Healthcare Financial services Manufacturing Government View all industries View all solutions Resources EXPLORE BY TOPIC AI Software Development DevOps Security View all topics EXPLORE BY TYPE Customer stories Events & webinars Ebooks & reports Business insights GitHub Skills SUPPORT & SERVICES Documentation Customer support Community forum Trust center Partners Open Source COMMUNITY GitHub Sponsors Fund open source developers PROGRAMS Security Lab Maintainer Community Accelerator Archive Program REPOSITORIES Topics Trending Collections Enterprise ENTERPRISE SOLUTIONS Enterprise platform AI-powered developer platform AVAILABLE ADD-ONS GitHub Advanced Security Enterprise-grade security features Copilot for Business Enterprise-grade AI features Premium Support Enterprise-grade 24/7 support Pricing Search or jump to... Search code, repositories, users, issues, pull requests... --> Search Clear Search syntax tips Provide feedback --> We read every piece of feedback, and take your input very seriously. Include my email address so I can be contacted Cancel Submit feedback Saved searches Use saved searches to filter your results more quickly --> Name Query To see all available qualifiers, see our documentation . Cancel Create saved search Sign in Sign up Appearance settings Resetting focus You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert {{ message }} mitul3737 Overview Repositories 152 More Overview Repositories 🏠 Working from home Md Shahriyar Al Mustakim Mitul mitul3737 🏠 Working from home @cncf Ambassador \| @campus-experts \| Reviewer @kubernetes Bengali Docs and CNCF Glossary \| Student Dhaka,Bangladesh X @mitul_shahriyar LinkedIn in/mitul-shahriyar YouTube @mitul_shahriyar https://patreon.com/MitulShahriyar Block or Report Block or report mitul3737 --> Block user Prevent this user from interacting with your repositories and sending you notifications. Learn more about blocking users . You must be logged in to block users. Add an optional note Maximum 250 characters. Please don't include any personal information such as legal names or email addresses. Markdown supported. This note will be visible to only you. Block user Report abuse Contact GitHub support about this user’s behavior. Learn more about reporting abuse . Report abuse Overview Repositories 152 More Overview Repositories mitul3737 / README .md Hi , I'm Shahriyar Al Mustakim Mitul About Me 🎓 I am a 4th year student pursuing Bachelors in Computer Science (CS) ⛵ Working in Cloud , DevOps, Quantum Computing & Deep Learning 😄 Pronouns: He/him/his @mitul3737's activity is private Footer © 2026 GitHub, Inc. Footer navigation Terms Privacy Security Status Community Docs Contact Manage cookies Do not share my personal information You can’t perform that action at this time.	2026-01-13T08:49:46
https://www.drupal.org/association/blog/drupalcon-vienna-2025-a-celebration-of-open-source-and-community-impact	DrupalCon Vienna 2025: A Celebration of Open Source and Community Impact \| Drupal.org Skip to main content Skip to search Can we use first and third party cookies and web beacons to understand our audience, and to tailor promotions you see ? Yes, please No, do not track me Drupal.org home Discover Drupal Drupal Core Drupal CMS Drupal AI Case Studies Drupal for Government Drupal for Higher Education Drupal for Nonprofit Drupal for eCommerce Drupal for FinTech Drupal for Healthcare Drupal for Enterprise Drupal for Retail Drupal for Travel & Tourism Build with Drupal Download Drupal Documentation Getting started Local Development Guide Developer Resources Drupal CMS User Guide Drupal User Guide API Modules Themes Distributions Issue queues Security Advisories Partners & Services Find a Drupal Certified Partner Become a Drupal Certified Partner Find a Hosting Provider Find a Migration Partner Find Training Drupal Steward Community About the Community How to Contribute DrupalCon Events Jobs / Careers News & Blogs Forum Slack Newsletters Drupal Swag Shop Support Drupal The Drupal Association Donate Become a Partner Become a Ripple Maker Become an Organization Member Drupal Swag Shop Get Started Try Drupal CMS Try Hosting Return to content Search form Search Log in Create account Still on Drupal 7? Security support for Drupal 7 ended on 5 January 2025. Please visit our Drupal 7 End of Life resources page to review all of your options. Migration Resource Center Drupal Association Blog DrupalCon Vienna 2025: A Celebration of Open Source and Community Impact By Drupal Association on 26 November 2025 The following is a guest post from DrupalCon Vienna Marketing Committee. When the Drupal community gathers, something extraordinary happens. From 14 to 17 October 2025 , nearly a thousand people came together at the Austria Center Vienna, Austria to celebrate open source, exchange ideas, and contribute to the future of Drupal. DrupalCon Vienna 2025 was not only a conference, it was a living example of collaboration, diversity, and innovation in action. A Community in Numbers This year’s event welcomed 935 registered participants , with an impressive 96.04% check-in rate . Interest in DrupalCon Vienna built steadily through the year, with the highest number of registrations coming in June (307) and September (236) . A Truly Global Audience DrupalCon Vienna brought together a remarkable mix of voices and perspectives. Participants represented over 40 countries , with 85% coming from across Europe , 8% from the United States , and 7% from other regions . The top ten countries represented were: United Kingdom (112) Germany (107) United States (75) Belgium (74) Austria (71) France (67) Spain (34) Netherlands (31) Sweden (26) Italy (24) From Costa Rica to Kenya , from Armenia to New Zealand , attendees crossed borders, time zones, and languages to connect through one shared passion - Drupal . New Faces and Familiar Friends One of the most inspiring aspects of the Drupal community is its balance between newcomers and long-time contributors . In Vienna, 28% of participants attended their first DrupalCon , while 38% had taken part in four or more DrupalCons. This mix of fresh enthusiasm and deep experience keeps the community dynamic and forward-looking . For the first time, this year’s DrupalCon introduced Drupal in a Day , organized by Hilmar Kári Hallbjörnsson . The training session welcomed 113 learners , aged 18 to 52 , highlighting the wide range of people discovering Drupal for the first time. Attendee Background An impressive 38% of attendees were delegated by their company to attend DrupalCon Vienna. Attendees were mainly represented by: Technical users: 37% Technical decision-makers: 27% Owners or business decision-makers: 21% In terms of expertise: 36% described themselves as Drupal experts 28% reported strong Drupal expertise The majority of participants ( 53% ) came from digital agencies, design, or development shops . They represented a variety of industries, with the strongest presence from: Services: 31% Government: 16% Education: 11% Powered by People Behind the scenes, the heart of DrupalCon beats thanks to its volunteers . A huge thank-you goes to the committees, track teams, and on-site volunteers who made the event possible. This year, 56 on-site volunteers contributed their time and expertise, supporting session reviews, contribution mentoring, information desks, and photography. Their dedication ensured that every attendee could learn, contribute, and feel part of something bigger . Made Possible by Our Sponsors None of this would have been possible without the generous support of our sponsors . Diamond: 3 Platinum: 4 Gold: 8 Silver: 6 Module: 10 Media: 5 Their continued investment in Drupal helps us deliver high-quality, inclusive, and impactful events that keep the open-source spirit alive . Looking Ahead DrupalCon Vienna 2025 reminded us that open source is more than code. It is community, creativity, and collaboration in action . Thank you to everyone who joined and contributed to making DrupalCon Vienna 2025 a success. Association blog News and updates from the Drupal Association. Learn how we help the Drupal project flourish. Infrastructure management for Drupal.org provided by Need a Drupal 7 extended support partner? Consider Tag1. News items News Planet Drupal Social media Sign up for Drupal news Security advisories Jobs Our community Community Services , Training & Hosting Contributor guide Groups & meetups DrupalCon Code of conduct Documentation Documentation Drupal Guide Drupal User Guide Developer docs API.Drupal.org Drupal code base Download & Extend Drupal core Modules Themes Distributions Governance of community About Web accessibility Drupal Association About Drupal.org Terms of service Privacy policy Drupal is a registered trademark of Dries Buytaert .	2026-01-13T08:49:46
https://magazine.joomla.org/all-issues/november-2025/joomla-now-officially-recognized-as-a-digital-public-good	Joomla Now Officially Recognized as a Digital Public Good - The Joomla Community Magazine Joomla! ® About us Joomla Home What is Joomla? Benefits & Features Project & Leadership Trademark & Licensing The Joomla Foundation Support us Contribute Sponsor Partner Shop Download & Extend Downloads Extensions Languages Get a free site Get a domain Discover & Learn Documentation Training Certification Site Showcase Announcements Blogs Magazine Community & Support Community Portal Events User Groups Forum Service Providers Directory Volunteers Portal Vulnerable Extensions List Developer Resources Developer Network Security Centre Issue Tracker GitHub API Documentation Joomla! Framework Search Community Magazine Download Launch Home Issues Authors Newsletter About FAQ 5 minutes reading time (922 words) Joomla Now Officially Recognized as a Digital Public Good November Angie Radtke Thursday, 20 November 2025 1101 Hits 0 Comments Joomla is now officially recognized as a digital public good, an accolade from the Digital Public Goods Alliance (DPGA). This recognition places Joomla among a number of international open source projects that prioritize openness, transparency, data protection, and social impact. Important to note: DPG recognition was granted only to Joomla as a digital solution, not to Joomla as an organization. The DPGA, supported by the United Nations, maintains an international registry of digital public goods and evaluates initiatives according to clearly defined standards. Its goal is to promote high-quality open-source projects that contribute to the UN Sustainable Development Goals (SDGs) and address urgent development needs worldwide. To be recognized as a digital public good must meet the Digital Public Goods Standard, which includes the following, among other things: Open licensing, e.g., recognized open-source licenses Data protection and security Compliance with legal and ethical standards Contribution to the UN Sustainable Development Goals Transparent governance and long-term sustainability Recognition as a digital public good is not automatic: Joomla underwent a thorough application and review process. Many questions had to be answered, and numerous community members contributed their expertise to achieve this success. From many individual pieces, an impressive overall picture emerged, clearly demonstrating Joomla’s versatility and the opportunities the system offers. A summary can be found on the Digital Public Good Alliance website here: https://www.digitalpublicgoods.net/r/joomla-joomla-content-management-system Visibility, Quality, and Social Impact Joomla has often struggled to showcase its excellence. The recognition as a digital public good now significantly enhances its visibility. It serves as a quality seal, signaling trust and reliability. For governments, organizations, and companies worldwide, this means: Joomla is now an open, trustworthy, and future-proof solution, enabling projects to be implemented efficiently, accessibly, and successfully. Background Digital sovereignty means being able to act independently, consciously, and self-determined in the digital realm – whether as an individual, a company, or a state. It does not mean doing everything alone or developing all technologies in-house. Rather, it is about making thoughtful and responsible decisions regarding which technologies and providers to use, which data to share, and how to manage one’s own data. A large part of the global digital infrastructure – especially around 80% of cloud services – is operated by a few major U.S. companies such as Amazon, Microsoft, and Google. Many companies and public authorities use products like Windows or Office 365, which are hosted in Microsoft’s cloud, because they work reliably and are easy to use. Programs like Word or Excel are familiar to almost everyone, and many learn them in school. For many, they have become indispensable tools in daily work. However, this concentration not only creates technical dependencies but also introduces security and political risks. The UN and Open-Source Software Principles To achieve digital sovereignty, it is necessary to use open and adaptable software that allows the independent development and operation of systems – for example, in healthcare, education, or public administration – without relying on large tech companies. This way, states, authorities, and organizations retain control over their data, infrastructure, and digital decisions. Open-source software is ideal for this because it: Provides control over the technology used Can be flexibly adapted to individual needs Strengthens the protection of one’s own data At the same time, open source is easy to share. In public administration, many tasks are very similar or even identical across different countries, for example, managing citizen data, processing applications, or handling document management. Instead of each country developing its own solutions from scratch, open-source applications can be shared, further developed, and adapted to local requirements. This not only saves time and money but also promotes international collaboration and knowledge exchange. Global Importance of Open Source These benefits are recognized at the global level, as shown by the UN Open-Source Software Principles. They promote a responsible and sustainable use of open source within the UN system. Many UN organizations currently develop digital solutions independently, leading to isolated systems, missing standards, and unnecessary costs. The principles aim to address these issues and strengthen digital collaboration. Their goal is to create open, trustworthy, and reusable software solutions that can be used worldwide – especially in less developed regions. Open source is intended to facilitate the exchange of knowledge and technology, strengthen cooperation between UN entities and external partners, and foster innovation, transparency, and long-term sustainability. This underscores how important open source is for both individual countries and global digital collaboration. Digital Public Goods: Open Software Solutions for Global Sustainability The UN Open-Source Principles define how open source should be used responsibly. Digital public goods show what can emerge from this – namely, digital commons that contribute worldwide to achieving the Sustainable Development Goals (SDGs). This can involve either a new project developed openly and collaboratively from the start, or existing open-source projects, such as Joomla, being strengthened by being reused, improved, and reintegrated into the community through so-called re-contributions – i.e., feedback of improvements and adaptations. This creates a cycle of use, further development, and shared responsibility. Many organizations, administrations, or development projects face the question of which digital solutions are trustworthy and suitable for long-term use – especially in sensitive areas like education, health, or administration. This is where the Digital Public Goods Alliance (DPGA) comes into play. The DPGA maintains an international registry of digital public goods that have been thoroughly reviewed. The list serves as a guideline for potential users, helping them find the software they need for their projects. Joomla is now part of this list and is officially recognized as a digital public good. Some articles published on the Joomla Community Magazine represent the personal opinion or experience of the Author on the specific topic and might not be aligned to the official position of the Joomla Project 2   Facebook   Twitter   LinkedIn   Pinterest Tags: DPG DPGA Digital Public Good Open Source The November Issue JoomlaDay France 2025 – Metz, an edition focused o... About the author Angie Radtke Angie Radtke   Comments Already Registered? Login Here No comments made yet. Be the first to submit a comment By accepting you will be accessing a service provided by a third-party external to https://magazine.joomla.org/ I understand and agree Direct Link Subscribe to the Joomla Community Magazine Newsletter Name Email I consent to The Joomla Project to collect, process, store and use my personal data in connection with the receipt by email of the Joomla Newsletter. Read the Privacy Policy Please enable the javascript to submit this form Current Issue The December Issue You are viewing the December issue of Joomla Community Magazine, our very last one this year. Like e... Restricting Full Articles to Registered Users While Showing an Intro Joomla’s built-in access control system is one of its strongest features and restricting content in ... Introducing the Advanced Migration Tool - My Journey from Idea to Release I’m excited to introduce the Advanced Migration Tool - a Joomla component that helps migrate WordPre... Blog Roll module On my site I want to have a module listing all the blog posts sorted by date. We can do this out of ... CSS Shorts: :has() The CSS :has() pseudo-class is often called the long-awaited “parent selector” in CSS, enabling deve... Case Study: Building a Multilingual AI Content Factory with Joomla & n8n In the world of digital content, consistency is everything. If you are a video creator, you know the... The Blind Spots of Accessibility Testing Tools - Labels and Input Fields Forms are a major area in accessibility testing, and ensuring they are fully accessible is essential... Dependency Injection: What and Why? If you use Joomla, you may have heard the term “dependency injection”. But what is it and why is it ... From Confusion to Clarity: Students Bring Fresh UX Vision to Joomla.org Joomla.org has long served a global and diverse community of users, from those encountering content ... How to set up a small business website in Joomla So you’ve installed Joomla and you’re looking at a shiny, fresh, but, most of all, empty backend. No... The Spirit of “Us”: How Joomla Builds Community Beyond Code In a world where technology often feels cold and competitive, Joomla proves that software can be hum... This was the JoomlaDay™ DACH 2025 In November the Joomla! community met in Bad Krozingen in Germany to join this year's JoomlaDay™ DAC... Your Code, in the Wild: Opportunities Inside the Joomla Ecosystem Young developers looking for meaningful open source projects: this one’s for you! Dileep Adari contr... Building a Joomla news feed that updates with Ajax This article started with a discussion about what we could do with the articles module in Joomla, th... View all Joomla! on Twitter Joomla! on Facebook Joomla! on YouTube Joomla! on LinkedIn Joomla! on Pinterest Joomla! on Instagram Joomla! on GitHub Home About Community Forum Extensions Services Docs Developer Shop Accessibility Statement Privacy Policy Cookie Policy Sponsor Joomla! with $5 Help Translate Report an Issue Log in © 2005 - 2026 Open Source Matters, Inc. All Rights Reserved. Joomla! Hosting by Rochen Close We have detected that you are using an ad blocker. The Joomla! Project relies on revenue from these advertisements so please consider disabling the ad blocker for this domain.	2026-01-13T08:49:46
https://discuss.opensource.org/t/distillation-and-oss-licensing/1333	Distillation and OSS Licensing - Open Source AI - OSI Discuss OSI Discuss Distillation and OSS Licensing Open Source AI jberkus December 8, 2025, 11:19pm 1 A point of OSD and OSS Licensing came up recently in discussion of a proposed OSS Model License that I’d love to discuss here at greater length. Specifically, this concerns attempts to enforce application of license terms to model distillation . Here is a sample clause from a draft license: “Derivative Materials” means all improvements, modifications or derivative works to the Licensed Material or any part thereof, which are created or developed by You (either by Yourself or jointly with other third parties), including any derivative model developed by transferring patterns of weights, parameters, activations and/or Output from the Model, such as through distillation methods or synthetic data generation techniques, in order to replicate, approximate, or otherwise achieve functional behavior that is similar to the Model. This kind of clause is understandable because of the practice of distillation, for example the creation of DeepSeek by training it on ChatGPT . This is a concern for model licensing, since distillation is even being offered as a service these days. This can be regarded by the model owner as a type of copying, although legally it may not be copying. This clause raises two questions for the concept of a copyleft license for models: Is this type of clause a violation of the OSD, if the clause does not prohibit distillation, but makes it subject to the conditions of the otherwise-OSS license? Does it violate OSD9 or OSD6 somehow? In copyright law, does a clause like this have any possible effect? Or is it cancelled out by the same kinds of precedents that allow LLMs to be trained on copyrighted material while ignoring license conditions? The OpenMDW license does not apply any conditions to model output. However, OpenMDW is also designed as a permissive license, applying minimal conditions to any use of the software. shujisado December 10, 2025, 3:41pm 2 I think this is a very thorny issue. To begin with, I do not think there is anything like a global consensus on it at this point. jberkus: Is this type of clause a violation of the OSD, if the clause does not prohibit distillation, but makes it subject to the conditions of the otherwise-OSS license? Does it violate OSD9 or OSD6 somehow? From my perspective, defining models that are technically dependent on the original model’s weights, activations, or outputs as “a kind of derivative work,” and then imposing copyleft obligations only on those models, is not something that can be said to be an Open Source Definition violation straight away. As long as we are talking purely about a copyleft requirement such as “if you distribute the derivative, you must use the same license,” the situations in which OSD #6 or #9 become directly problematic seem rather limited. That said, the scope of “technical dependence” is exactly where interpretations are likely to diverge between jurisdictions, and this is what makes the issue so tricky. How far one goes in treating something as “reliant on the original model” is entangled with copyright doctrines on derivative works and substantial reliance. jberkus: In copyright law, does a clause like this have any possible effect? Or is it cancelled out by the same kinds of precedents that allow LLMs to be trained on copyrighted material while ignoring license conditions? Looking only from the copyright-law angle, there is fair use in the United States, and TDM exceptions in the EU and Japan, and the act of training itself can potentially be justified within those frameworks. On the other hand, for users who download and use the model, there is at least room to argue that, if the license is treated as a contract, they incur an obligation “to use it in accordance with those conditions.” In other words, for users who actually receive the model artifact and the license text, I think there is some significance in imposing a duty such as “if you distribute a distilled model, you must release it under the same license.” By contrast, the situation is different in cases where someone performs distillation only via API calls or by scraping publicly available outputs. Such users may well never have accessed the model artifact or the license at all, and in that case one has to conclude that there is no agreement to the license in the first place, so the contractual terms simply do not reach them. Even if we assume that the clause is valid in principle, the practical cost of proving that “this smaller model is in fact a distillation of that specific model” is very high, so I am quite skeptical about how strong a deterrent effect it can actually have. jberkus December 10, 2025, 11:47pm 3 shujisado: In other words, for users who actually receive the model artifact and the license text, I think there is some significance in imposing a duty such as “if you distribute a distilled model, you must release it under the same license.” So you’re saying that the license under which the model was used could apply to use of the model’s output, even though the output itself might not be copyrightable? That seems reasonable in the context of models, but that brings us back into possible OSD9 violation. Consider, for example, a piece of graphics design software that asserted licensing conditions over and image created with it. We would not accept that as OSS. shujisado December 11, 2025, 11:31am 4 I think there is a slight misunderstanding of what I was trying to say. When I wrote: jberkus: shujisado: In other words, for users who actually receive the model artifact and the license text, I think there is some significance in imposing a duty such as “if you distribute a distilled model, you must release it under the same license.” I did not mean that the license would automatically attach to any and all uses of individual outputs. I was trying to describe a much narrower situation: There is a user who has actually downloaded the model artifact under a license, that license defines certain “Derivative Materials” in contractual terms, and among those, it includes “a new model created by using this model’s weights or outputs for distillation” and then it says “if you distribute that particular kind of model, you must do so under the same license.” In other words, the obligation is not arising because each output is copyrightable. It is arising, if at all, because the user has agreed by contract that “if I use this model in this particular way and then distribute the resulting model artifact, I will follow these conditions.” That feels different to me from the classic example of graphics software claiming licensing control over normal images created with it. In that graphics example, the tool is trying to control the user’s own creative works in general. In the distillation case, the license is trying to control a specific new model that is technically and statistically dependent on the licensed model, and only where the user has explicitly accepted that condition when downloading the original model. Whether such a clause should be considered compatible with the OSD is exactly the hard question, and I agree that OSD#9 is the place where the tension shows up. My point was only that, in legal terms, there is at least a colorable argument that this is a contractual obligation about a particular class of derivative models, not a general attempt to impose licensing conditions on arbitrary uses of uncopyrightable outputs. EMUCoupon December 25, 2025, 10:27am 5 This is a tricky area where open source principles and ML practices don’t fully align yet. From an OSD perspective, it likely doesn’t violate OSD6, but OSD9 is where things become less clear especially if copyleft obligations are being applied to models created through behavior learning rather than direct copying. Legally, enforceability is also uncertain. Copyright law doesn’t clearly treat distillation as creating a derivative work, which is why training on copyrighted material typically doesn’t carry over license terms. That uncertainty is probably why permissive licenses like OpenMDW avoid placing conditions on model outputs. 1 Like Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:46
https://forem.com/t/jokes/page/2	jokes Page 2 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close jokes Follow Hide plz post the lols Create Post submission guidelines no spam don't be offensive (sexist, racist, homophobic, crude, etc.), the DEV code of conduct is still in place! make the jokes programming related-ish Older #jokes posts 1 2 3 4 5 6 7 8 9 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu 💔 Love in the Time of Microservices. Madhu Madhu Madhu Follow Oct 24 '25 💔 Love in the Time of Microservices. # jokes # springboot # funny # programming Comments Add Comment 2 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Oct 6 '25 Meme Monday # discuss # watercooler # jokes 32 reactions Comments 39 comments 1 min read We Had Scrum Masters. Get Ready for the Vibe Code Cleanup Specialist Ahmad Kanj Ahmad Kanj Ahmad Kanj Follow for AWS Community Builders Oct 18 '25 We Had Scrum Masters. Get Ready for the Vibe Code Cleanup Specialist # jokes # agile # vibecoding 1 reaction Comments 1 comment 3 min read 🐶Spring Boot, but Every Exception Is a Dog Breed Madhu Madhu Madhu Follow Oct 15 '25 🐶Spring Boot, but Every Exception Is a Dog Breed # jokes # java # springboot 9 reactions Comments 2 comments 2 min read How Shipping Code in a Rush Can Cause Uncalculated Losses DivyanshuLohani DivyanshuLohani DivyanshuLohani Follow Sep 9 '25 How Shipping Code in a Rush Can Cause Uncalculated Losses # jokes # testing # softwareengineering # product Comments Add Comment 6 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 29 '25 Meme Monday # discuss # jokes # watercooler 27 reactions Comments 36 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 22 '25 Meme Monday # discuss # watercooler # jokes 31 reactions Comments 47 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 15 '25 Meme Monday # discuss # watercooler # jokes 34 reactions Comments 51 comments 1 min read What If CSS Properties Had Personalities Dennis Persson Dennis Persson Dennis Persson Follow Sep 28 '25 What If CSS Properties Had Personalities # jokes # webdev # css # programming 27 reactions Comments 4 comments 4 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 8 '25 Meme Monday # discuss # watercooler # jokes 39 reactions Comments 93 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 1 '25 Meme Monday # discuss # jokes # watercooler 57 reactions Comments 109 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 25 '25 Meme Monday # discuss # jokes # watercooler 17 reactions Comments 45 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 18 '25 Meme Monday # discuss # jokes # watercooler 26 reactions Comments 58 comments 1 min read Yeah, totally not a "Back-To-School" Challenge Dev.To AspXone AspXone AspXone Follow Aug 29 '25 Yeah, totally not a "Back-To-School" Challenge Dev.To # jokes # herokuchallenge 3 reactions Comments 7 comments 1 min read I made a professional-grade Brainfuck IDE. And used it to come closer than ever to running Doom in Brainfuck. Ahineya Ahineya Ahineya Follow Aug 28 '25 I made a professional-grade Brainfuck IDE. And used it to come closer than ever to running Doom in Brainfuck. # jokes # programming # computerscience # architecture 1 reaction Comments Add Comment 6 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 11 '25 Meme Monday # discuss # jokes # watercooler 31 reactions Comments 46 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 4 '25 Meme Monday # discuss # watercooler # jokes 43 reactions Comments 58 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 28 '25 Meme Monday # discuss # watercooler # jokes 26 reactions Comments 98 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 21 '25 Meme Monday # discuss # jokes # watercooler 31 reactions Comments 138 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 14 '25 Meme Monday # jokes # discuss # watercooler 46 reactions Comments 65 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 7 '25 Meme Monday # discuss # watercooler # jokes 52 reactions Comments 77 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jun 30 '25 Meme Monday # discuss # watercooler # jokes 38 reactions Comments 65 comments 1 min read The First Time I Saw a Computer—A Bit of Nostalgia Cesar Aguirre Cesar Aguirre Cesar Aguirre Follow Jun 30 '25 The First Time I Saw a Computer—A Bit of Nostalgia # discuss # watercooler # jokes # programming 15 reactions Comments 53 comments 2 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jun 23 '25 Meme Monday # discuss # jokes # watercooler 61 reactions Comments 69 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jun 16 '25 Meme Monday # discuss # watercooler # jokes 47 reactions Comments 74 comments 1 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:46
https://discuss.opensource.org/t/open-source-a-global-commons-to-enable-digital-sovereignty/1327	Open Source: A global commons to enable digital sovereignty - General - OSI Discuss OSI Discuss Open Source: A global commons to enable digital sovereignty General system November 24, 2025, 10:03am 1 Originally published at: Open Source: A global commons to enable digital sovereignty – Open Source Initiative In a world increasingly run by software, countries around the world are waking up to their dependency on foreign services and products. Geopolitical shifts drive digital sovereignty to the top of the political agenda in Europe and other regions. How can we ensure that regulations protecting our citizens actually apply? How do we guarantee continuity of operations in a potentially fragmenting world? How do we ensure access to critical services is not held hostage in future international trade negotiations? Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:46
https://dev.to/t/interview/page/72	Interview Page 72 - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close # interview Follow Hide Create Post Older #interview posts 69 70 71 72 73 74 75 76 77 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu CAP Theorem e pragmatismo nos estudos Erick Takeshi Erick Takeshi Erick Takeshi Follow Apr 6 '23 CAP Theorem e pragmatismo nos estudos # systemdesign # career # computerscience # interview 3 reactions Comments Add Comment 3 min read Find the Index of the First Occurrence in a String (Naive and KMP Solutions) Sean Coughlin Sean Coughlin Sean Coughlin Follow Apr 5 '23 Find the Index of the First Occurrence in a String (Naive and KMP Solutions) # interview # python # strings # kmp 1 reaction Comments Add Comment 6 min read Landing a Google SWE Internship: Interview Experience and preparation journey Arnab Sen Arnab Sen Arnab Sen Follow Apr 4 '23 Landing a Google SWE Internship: Interview Experience and preparation journey # interview # career # computerscience 2 reactions Comments Add Comment 13 min read The Ultimate List of QA Interview Questions to Secure Your Dream Job taniazhydkova taniazhydkova taniazhydkova Follow Apr 4 '23 The Ultimate List of QA Interview Questions to Secure Your Dream Job # job # career # interview # qa 1 reaction Comments Add Comment 4 min read Developer Spotlight: Nika Salamadze Andrew MacLean Andrew MacLean Andrew MacLean Follow for DevCycleHQ Mar 31 '23 Developer Spotlight: Nika Salamadze # featureflags # devops # spotlight # interview 5 reactions Comments Add Comment 3 min read Module Federation v7 featuring Delegate Modules Viktoriia Lurie Viktoriia Lurie Viktoriia Lurie Follow for Valor Labs Mar 16 '23 Module Federation v7 featuring Delegate Modules # modulefederation # interview # webdev 2 reactions Comments Add Comment 20 min read Useful Resources to Prepare for Data Scientist Interviews Johnny Shollaj Johnny Shollaj Johnny Shollaj Follow Mar 11 '23 Useful Resources to Prepare for Data Scientist Interviews # datascience # machinelearning # interview 1 reaction Comments Add Comment 2 min read 20+ interview questions that you should get answered before going further Teo Deleanu Teo Deleanu Teo Deleanu Follow Mar 7 '23 20+ interview questions that you should get answered before going further # interview # fullstack # 10x # layoffs 5 reactions Comments Add Comment 4 min read Polyfill for map in javascript Gurmeet Singh Gurmeet Singh Gurmeet Singh Follow Mar 5 '23 Polyfill for map in javascript # javascript # interview # polyfill 1 reaction Comments 1 comment 2 min read Choosing Between ReactJS and VueJS: A Developer's Guide. Alexander Maina Alexander Maina Alexander Maina Follow Mar 2 '23 Choosing Between ReactJS and VueJS: A Developer's Guide. # webdev # beginners # javascript # interview 11 reactions Comments 3 comments 6 min read Get started with CloudFront - Part 3: Response Headers and Cache Behavior Van Hoang Kha Van Hoang Kha Van Hoang Kha Follow for AWS Community Builders Mar 1 '23 Get started with CloudFront - Part 3: Response Headers and Cache Behavior # interview # career # showcase # writing 9 reactions Comments Add Comment 3 min read Array same length challenge Lautaro Suarez Lautaro Suarez Lautaro Suarez Follow Feb 28 '23 Array same length challenge # interview # javascript # array # beginners 1 reaction Comments Add Comment 2 min read JavaScript interview questions. Lautaro Suarez Lautaro Suarez Lautaro Suarez Follow Feb 27 '23 JavaScript interview questions. # javascript # programming # interview 2 reactions Comments Add Comment 5 min read Do you have any questions? Mykolas Mankevicius Mykolas Mankevicius Mykolas Mankevicius Follow Feb 27 '23 Do you have any questions? # interview # beginners # programming # career Comments Add Comment 1 min read Beware of Fake Job Offers: My Encounter with a Scammer David Chedrick David Chedrick David Chedrick Follow Feb 24 '23 Beware of Fake Job Offers: My Encounter with a Scammer # webdev # career # interview # scam 13 reactions Comments 5 comments 8 min read How to Ace Your Technical Interview Michael J. Larocca Michael J. Larocca Michael J. Larocca Follow Feb 21 '23 How to Ace Your Technical Interview # scrimba # interview # git # portfolio 5 reactions Comments Add Comment 8 min read Developer Spotlight: Laura Warr Andrew MacLean Andrew MacLean Andrew MacLean Follow for DevCycleHQ Mar 30 '23 Developer Spotlight: Laura Warr # featureflags # devops # spotlight # interview Comments Add Comment 3 min read The Ultimate List of Job Hunting Resources for Software Developers Part 6: Computer Science Fundamentals devgrowth devgrowth devgrowth Follow Feb 15 '23 The Ultimate List of Job Hunting Resources for Software Developers Part 6: Computer Science Fundamentals # computerscience # interview # interviewpreparation # interviewprep 2 reactions Comments Add Comment 1 min read The Ultimate List of Job Hunting Resources for Software Developers Part 5: Behavior Round devgrowth devgrowth devgrowth Follow Feb 14 '23 The Ultimate List of Job Hunting Resources for Software Developers Part 5: Behavior Round # interview # interviewpreparation # interviewprep # behavioral 2 reactions Comments Add Comment 1 min read Understanding Networking Protocols for nailing your next DevOps Interview Pragyan Tripathi Pragyan Tripathi Pragyan Tripathi Follow Feb 14 '23 Understanding Networking Protocols for nailing your next DevOps Interview # devops # devjournal # networkingprotocols # interview 3 reactions Comments 1 comment 2 min read The Ultimate List of Job Hunting Resources for Software Developers Part 4: Prepare For System Design Interview devgrowth devgrowth devgrowth Follow Feb 11 '23 The Ultimate List of Job Hunting Resources for Software Developers Part 4: Prepare For System Design Interview # systemdesign # interview # interviewprep # interviewpreparation 1 reaction Comments Add Comment 3 min read 12 OS concepts you must master to ace your next DevOps Interview Pragyan Tripathi Pragyan Tripathi Pragyan Tripathi Follow Feb 7 '23 12 OS concepts you must master to ace your next DevOps Interview # devops # devjournal # interview # developers 4 reactions Comments 2 comments 2 min read Top 20 React.JS interview questions. ABU SAID ABU SAID ABU SAID Follow Jan 30 '23 Top 20 React.JS interview questions. # react # interview # nextjs # node 122 reactions Comments 6 comments 8 min read Developer Spotlight: François-Xavier Beckers Andrew MacLean Andrew MacLean Andrew MacLean Follow for DevCycleHQ Mar 29 '23 Developer Spotlight: François-Xavier Beckers # featureflags # devops # spotlight # interview Comments Add Comment 5 min read how to count a number of vowels and consonants in a given string in java realNameHidden realNameHidden realNameHidden Follow Jan 28 '23 how to count a number of vowels and consonants in a given string in java # java # interview 3 reactions Comments Add Comment 1 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:46
https://discuss.opensource.org/t/patents-and-open-source-understanding-the-risks-and-available-solutions/1331	Patents and Open Source: Understanding the Risks and Available Solutions - General - OSI Discuss OSI Discuss Patents and Open Source: Understanding the Risks and Available Solutions General system December 4, 2025, 4:00pm 1 Originally published at: https://opensource.org/blog/patents-and-open-source-understanding-the-risks-and-available-solutions The Open Source community has spent two decades building the scaffolding to make patent threats rare and containable. Developers who understand that landscape can focus on what they do best: innovating in the open, confident that the legal ground beneath them is far more stable than any patent myths suggest. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:46
https://opensource.org/blog/open-source-without-borders-reflections-from-coscon25#content	Open Source Without Borders: Reflections from COSCon’25 – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu December 10, 2025 Events Nick Vidal Open Source Without Borders: Reflections from COSCon’25 Last week, I had the honor of delivering the opening keynote at the China Open Source Conference (COSCon’25) in Beijing, as Kaiyuanshe celebrated its 10th anniversary. Standing before a community that this year is witnessing a “Deepseek moment” driven by open innovation was both humbling and inspiring. The conference offered rich opportunities for engagement: from a panel discussion about “AI as a Global Digital Public Good” to a meeting with the Kaiyuanshe Advisory Committee exploring opportunities for global collaboration. I also enjoyed meeting with many members of the community at the hallway track and at the amazing fair. Challenges and Opportunities My keynote, “ Open Source Without Borders: The OSI and Kaiyuanshe Journey and the Road Ahead ,” traced the interconnected histories of the Free Software and Open Source movements that emerged in response to a fundamental challenge developers were facing at the time: restrictions and constraints imposed by proprietary software. Those early fights for freedom laid the foundation for today’s global, collaborative ecosystem. As we stand at the crossroads of emerging challenges, from AI to cybersecurity and digital sovereignty, the role of Open Source and the fight for freedom have never been more critical. Throughout my presentation, I emphasized how the OSI continues to anchor community consensus on what constitutes Open Source, protect the principles and communities that depend on them, and lead global conversations about the future of our ecosystem. I shared OSI’s work across three pillars: License & Legal (maintaining the OSI Approved Licenses database), Policy & Standards (including the Open Policy Alliance), and Advocacy & Research (e.g. our participation at events like the Open Source Congress and the DPGA’s Annual Members Meeting). One of the highlights of the keynote was the presentation of the Open Source AI Definition , being developed as a co-design process in which global experts establish a shared set of principles that can recreate the permissionless, pragmatic and simplified collaboration for AI practitioners. An Open Source AI system must grant the freedoms to use, study, modify, and share, supported by access to data information, code, and parameters. I also highlighted the data governance challenges we face in Open Source AI: Openness, fair use, copyright and community compensation Bias, diversity and real-world harms Transparency, privacy and security tradeoffs Interoperability and technical barriers AI’s environmental and climate impact Cross-border collaboration amid geopolitics Policies that ensure auditability and public trust But challenges present opportunities. The timing felt particularly significant: China’s “Deepseek moment” is a powerful demonstration of how the hacker mindset and the collaborative nature is helping the global AI community to overcome many of the challenges shared above. I concluded my keynote with a poem inspired by an ancient Chinese wisdom: “穷则变，变则通，通则久”  When circumstances reach a limit, change brings opportunity; with change comes solutions; with solutions comes continuity. Follow the hacker mindset: seek new ways and work in the open; bypass all limits and constraints; build solutions and fix what’s broken. The road ahead is full of obstacles, but every barrier is a doorway. Open Source is the key; let the community light the way. The Road Ahead I’m deeply grateful to Kaiyuanshe for the invitation to join COSCon’25 . A very special thank you to Emily Chen, Nadia Jiang, Richard Lin, the Kaiyuanshe Board, and all the organizers and volunteers who made the event a great success. Witnessing China’s Deepseek moment firsthand and learning about Kaiyuanshe’s dedication for over a decade building and championing China’s Open Source community with such vision and commitment is truly inspiring. The OSI is honored to be walking this road alongside communities like Kaiyuanshe, building Open Source without borders. The future of Open Source will not be defined by the obstacles we face, but by the collective strength we bring to overcoming them. Challenges are simply the gateways to new opportunities. And with communities like Kaiyuanshe, we have every reason to believe that the journey ahead will be one of greater openness, deeper collaboration, and shared triumph. OSI_COSCon Download DPGA’s Annual Members Meeting: Advancing Open Source & DPGs for the Public Good Celebrating Generosity and Growth in the OSI Community Keep up with Open Source Please leave this field empty. Δ We’ll never share your details and you can unsubscribe with a click! Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://discuss.opensource.org/t/open-policy-alliance-welcomes-the-open-source-technology-improvement-fund-as-new-member/1353	Open Policy Alliance Welcomes the Open Source Technology Improvement Fund as New Member - General - OSI Discuss OSI Discuss Open Policy Alliance Welcomes the Open Source Technology Improvement Fund as New Member General system January 8, 2026, 3:00pm 1 Originally published at: Open Policy Alliance Welcomes the Open Source Technology Improvement Fund as New Member – Open Source Initiative The Open Source Initiative (OSI) is pleased to welcome the Open Source Technology Improvement Fund (OSTIF) to the Open Policy Alliance. OSTIF is a nonprofit dedicated to securing Open Source apps. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:46
https://forem.com/t/containers/page/12	Containers Page 12 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close # containers Follow Hide Security for container technologies like Docker and orchestration platforms like Kubernetes. Create Post Older #containers posts 9 10 11 12 13 14 15 16 17 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Docker Best Practices to Secure and Optimize Your Containers Dmitry Protsenko Dmitry Protsenko Dmitry Protsenko Follow Sep 29 '25 Docker Best Practices to Secure and Optimize Your Containers # docker # containers # kubernetes # devops 8 reactions Comments Add Comment 13 min read AWS Cloud Practitioner Questions \| Containers in AWS Minoltan Issack Minoltan Issack Minoltan Issack Follow Sep 29 '25 AWS Cloud Practitioner Questions \| Containers in AWS # aws # containers # cloud # kubernetes 1 reaction Comments 1 comment 4 min read 100 Days of DevOps: Day 57 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 29 '25 100 Days of DevOps: Day 57 # devops # kubernetes # containers # bash 1 reaction Comments Add Comment 4 min read 100 Days of DevOps: Day 56 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 28 '25 100 Days of DevOps: Day 56 # devops # kubernetes # linux # containers 1 reaction Comments Add Comment 2 min read What's in new Kubernetes v1.34 Of Wind & Will kaustubh yerkade kaustubh yerkade kaustubh yerkade Follow Sep 27 '25 What's in new Kubernetes v1.34 Of Wind & Will # kubernetes # devops # cloud # containers Comments Add Comment 2 min read 100 Days of DevOps: Day 53 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 27 '25 100 Days of DevOps: Day 53 # devops # kubernetes # containers # linux 1 reaction Comments 1 comment 3 min read 100 Days of DevOps: Day 55 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 27 '25 100 Days of DevOps: Day 55 # devops # nginx # kubernetes # containers 1 reaction Comments Add Comment 2 min read Docker Compose: Speed Up Your Workflow with Profiles, Extends and Depends_on Altair Lage Altair Lage Altair Lage Follow Aug 27 '25 Docker Compose: Speed Up Your Workflow with Profiles, Extends and Depends_on # docker # devops # containers # programming Comments Add Comment 9 min read toolbox, IDEs and atomic desktops Rodolfo Olivieri Rodolfo Olivieri Rodolfo Olivieri Follow Nov 11 '25 toolbox, IDEs and atomic desktops # fedora # atomic # containers Comments Add Comment 4 min read Deep Dive into ECS Task Definitions: The Blueprint of Your Containers On-cloud7 On-cloud7 On-cloud7 Follow Sep 25 '25 Deep Dive into ECS Task Definitions: The Blueprint of Your Containers # docker # aws # containers # devops 5 reactions Comments Add Comment 3 min read Kubernetes Debug Container satwik raj satwik raj satwik raj Follow Sep 24 '25 Kubernetes Debug Container # containers # devops # kubernetes 1 reaction Comments 1 comment 3 min read Building a Practical DevSecOps Pipeline: From Basic Security to Enterprise-Style Protection Rajesh Pethe Rajesh Pethe Rajesh Pethe Follow Sep 24 '25 Building a Practical DevSecOps Pipeline: From Basic Security to Enterprise-Style Protection # devops # python # containers # cicd Comments Add Comment 6 min read Kubernetes Security Book (2nd Edition) — A Synthesis Alain Airom Alain Airom Alain Airom Follow Sep 24 '25 Kubernetes Security Book (2nd Edition) — A Synthesis # kubernetes # cloudnative # security # containers 2 reactions Comments 2 comments 5 min read 100 Days of DevOps: Day 52 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 24 '25 100 Days of DevOps: Day 52 # devops # kubernetes # containers # container 1 reaction Comments Add Comment 1 min read Complete Ansible Guide Maksym Maksym Maksym Follow Sep 23 '25 Complete Ansible Guide # docker # containers # ansible Comments Add Comment 6 min read Docker's Copy-on-Write (CoW) Principle: A Deep Dive into Efficient Containerization Bhavya Singh Bhavya Singh Bhavya Singh Follow Sep 23 '25 Docker's Copy-on-Write (CoW) Principle: A Deep Dive into Efficient Containerization # docker # cow # containers # storage Comments Add Comment 7 min read Docker Doesn’t Bite: A Beginner’s Guide Imthadh Ahamed Imthadh Ahamed Imthadh Ahamed Follow Sep 23 '25 Docker Doesn’t Bite: A Beginner’s Guide # docker # cicd # containers # kubernetes Comments Add Comment 3 min read 100 Days of DevOps: Day 51 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 23 '25 100 Days of DevOps: Day 51 # devops # nginx # kubernetes # containers 1 reaction Comments Add Comment 3 min read Containerization Without the Cloud: Running Docker Locally for Fun and Speed Prosper Spot Prosper Spot Prosper Spot Follow Sep 22 '25 Containerization Without the Cloud: Running Docker Locally for Fun and Speed # docker # containers # tutorial # beginners Comments Add Comment 4 min read Deploying Containers on AWS: The One Guide You Need Hasan Ashab Hasan Ashab Hasan Ashab Follow Sep 22 '25 Deploying Containers on AWS: The One Guide You Need # aws # containers # cloud # kubernetes Comments Add Comment 2 min read 100 Days of DevOps: Day 50 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 22 '25 100 Days of DevOps: Day 50 # containers # kubernetes # programming # devops 1 reaction Comments Add Comment 2 min read Setting Up Kubernetes on Windows with Minikube (Step-by-Step Guide) Abhishek Korde Abhishek Korde Abhishek Korde Follow Sep 20 '25 Setting Up Kubernetes on Windows with Minikube (Step-by-Step Guide) # kubernetes # docker # containers # cloud 5 reactions Comments Add Comment 5 min read 100 Days of DevOps: Day 48 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 20 '25 100 Days of DevOps: Day 48 # linux # kubernetes # devops # containers 2 reactions Comments Add Comment 3 min read Virtualization vs. Containerization: The Ultimate Showdown Raj Singhal Raj Singhal Raj Singhal Follow Sep 19 '25 Virtualization vs. Containerization: The Ultimate Showdown # docker # virtualization # containers # beginners 1 reaction Comments Add Comment 3 min read 100 Days of DevOps: Day 47 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Sep 19 '25 100 Days of DevOps: Day 47 # docker # containers # container # python 1 reaction Comments Add Comment 2 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:46
https://opensource.org/?p=293587	Open Source Without Borders: Reflections from COSCon’25 – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu December 10, 2025 Events Nick Vidal Open Source Without Borders: Reflections from COSCon’25 Last week, I had the honor of delivering the opening keynote at the China Open Source Conference (COSCon’25) in Beijing, as Kaiyuanshe celebrated its 10th anniversary. Standing before a community that this year is witnessing a “Deepseek moment” driven by open innovation was both humbling and inspiring. The conference offered rich opportunities for engagement: from a panel discussion about “AI as a Global Digital Public Good” to a meeting with the Kaiyuanshe Advisory Committee exploring opportunities for global collaboration. I also enjoyed meeting with many members of the community at the hallway track and at the amazing fair. Challenges and Opportunities My keynote, “ Open Source Without Borders: The OSI and Kaiyuanshe Journey and the Road Ahead ,” traced the interconnected histories of the Free Software and Open Source movements that emerged in response to a fundamental challenge developers were facing at the time: restrictions and constraints imposed by proprietary software. Those early fights for freedom laid the foundation for today’s global, collaborative ecosystem. As we stand at the crossroads of emerging challenges, from AI to cybersecurity and digital sovereignty, the role of Open Source and the fight for freedom have never been more critical. Throughout my presentation, I emphasized how the OSI continues to anchor community consensus on what constitutes Open Source, protect the principles and communities that depend on them, and lead global conversations about the future of our ecosystem. I shared OSI’s work across three pillars: License & Legal (maintaining the OSI Approved Licenses database), Policy & Standards (including the Open Policy Alliance), and Advocacy & Research (e.g. our participation at events like the Open Source Congress and the DPGA’s Annual Members Meeting). One of the highlights of the keynote was the presentation of the Open Source AI Definition , being developed as a co-design process in which global experts establish a shared set of principles that can recreate the permissionless, pragmatic and simplified collaboration for AI practitioners. An Open Source AI system must grant the freedoms to use, study, modify, and share, supported by access to data information, code, and parameters. I also highlighted the data governance challenges we face in Open Source AI: Openness, fair use, copyright and community compensation Bias, diversity and real-world harms Transparency, privacy and security tradeoffs Interoperability and technical barriers AI’s environmental and climate impact Cross-border collaboration amid geopolitics Policies that ensure auditability and public trust But challenges present opportunities. The timing felt particularly significant: China’s “Deepseek moment” is a powerful demonstration of how the hacker mindset and the collaborative nature is helping the global AI community to overcome many of the challenges shared above. I concluded my keynote with a poem inspired by an ancient Chinese wisdom: “穷则变，变则通，通则久”  When circumstances reach a limit, change brings opportunity; with change comes solutions; with solutions comes continuity. Follow the hacker mindset: seek new ways and work in the open; bypass all limits and constraints; build solutions and fix what’s broken. The road ahead is full of obstacles, but every barrier is a doorway. Open Source is the key; let the community light the way. The Road Ahead I’m deeply grateful to Kaiyuanshe for the invitation to join COSCon’25 . A very special thank you to Emily Chen, Nadia Jiang, Richard Lin, the Kaiyuanshe Board, and all the organizers and volunteers who made the event a great success. Witnessing China’s Deepseek moment firsthand and learning about Kaiyuanshe’s dedication for over a decade building and championing China’s Open Source community with such vision and commitment is truly inspiring. The OSI is honored to be walking this road alongside communities like Kaiyuanshe, building Open Source without borders. The future of Open Source will not be defined by the obstacles we face, but by the collective strength we bring to overcoming them. Challenges are simply the gateways to new opportunities. And with communities like Kaiyuanshe, we have every reason to believe that the journey ahead will be one of greater openness, deeper collaboration, and shared triumph. OSI_COSCon Download DPGA’s Annual Members Meeting: Advancing Open Source & DPGs for the Public Good Celebrating Generosity and Growth in the OSI Community Keep up with Open Source Please leave this field empty. Δ We’ll never share your details and you can unsubscribe with a click! Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:46
https://discuss.opensource.org/t/open-source-without-borders-reflections-from-coscon25/1334	Open Source Without Borders: Reflections from COSCon'25 - General - OSI Discuss OSI Discuss Open Source Without Borders: Reflections from COSCon'25 General system December 10, 2025, 8:15am 1 Originally published at: Open Source Without Borders: Reflections from COSCon’25 – Open Source Initiative Reflections from COSCon’25: Witnessing China’s Deepseek moment firsthand and learning about Kaiyuanshe’s dedication for over a decade building and championing China’s Open Source community with such vision and commitment is truly inspiring. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:46
https://llvm.org/docs/LangRef.html#constant-expressions	LLVM Language Reference Manual — LLVM 22.0.0git documentation Navigation index next \| previous \| LLVM Home  \|  Documentation » Reference » LLVM Language Reference Manual Documentation Getting Started/Tutorials User Guides Reference Getting Involved Contributing to LLVM Submitting Bug Reports Mailing Lists Discord Meetups and Social Events Additional Links FAQ Glossary Publications Github Repository This Page Show Source Quick search LLVM Language Reference Manual ¶ Abstract Introduction Well-Formedness Syntax Identifiers String constants High Level Structure Module Structure Linkage Types Calling Conventions Visibility Styles DLL Storage Classes Thread Local Storage Models Runtime Preemption Specifiers Structure Types Non-Integral Pointer Type Pointers with non-address bits Unstable pointer representation Pointers with external state Global Variables Functions Aliases IFuncs Comdats Named Metadata Parameter Attributes Garbage Collector Strategy Names Prefix Data Prologue Data Personality Function Attribute Groups Function Attributes Call Site Attributes Global Attributes Operand Bundles Deoptimization Operand Bundles Funclet Operand Bundles GC Transition Operand Bundles Assume Operand Bundles Preallocated Operand Bundles GC Live Operand Bundles ObjC ARC Attached Call Operand Bundles Pointer Authentication Operand Bundles KCFI Operand Bundles Convergence Control Operand Bundles Deactivation Symbol Operand Bundles Module-Level Inline Assembly Data Layout Target Triple Allocated Objects Object Lifetime Pointer Aliasing Rules Pointer Capture Volatile Memory Accesses Memory Model for Concurrent Operations Atomic Memory Ordering Constraints Floating-Point Environment Behavior of Floating-Point NaN values Floating-Point Semantics Fast-Math Flags Rewrite-based flags Use-list Order Directives Source Filename Type System Void Type Function Type Opaque Structure Types First Class Types Single Value Types Label Type Token Type Metadata Type Aggregate Types Constants Simple Constants Complex Constants Global Variable and Function Addresses Undefined Values Poison Values Well-Defined Values Addresses of Basic Blocks DSO Local Equivalent No CFI Pointer Authentication Constants Constant Expressions Other Values Inline Assembler Expressions Inline Asm Constraint String Asm template argument modifiers Inline Asm Metadata Metadata Metadata Strings ( MDString ) Metadata Nodes ( MDNode ) Specialized Metadata Nodes ‘ tbaa ’ Metadata ‘ tbaa.struct ’ Metadata ‘ noalias ’ and ‘ alias.scope ’ Metadata ‘ fpmath ’ Metadata ‘ range ’ Metadata ‘ absolute_symbol ’ Metadata ‘ callees ’ Metadata ‘ callback ’ Metadata ‘ exclude ’ Metadata ‘ unpredictable ’ Metadata ‘ dereferenceable ’ Metadata ‘ dereferenceable_or_null ’ Metadata ‘ captures ’ Metadata ‘ llvm.loop ’ ‘ llvm.loop.disable_nonforced ’ ‘ llvm.loop.vectorize ’ and ‘ llvm.loop.interleave ’ ‘ llvm.loop.interleave.count ’ Metadata ‘ llvm.loop.vectorize.enable ’ Metadata ‘ llvm.loop.vectorize.predicate.enable ’ Metadata ‘ llvm.loop.vectorize.scalable.enable ’ Metadata ‘ llvm.loop.vectorize.width ’ Metadata ‘ llvm.loop.vectorize.followup_vectorized ’ Metadata ‘ llvm.loop.vectorize.followup_epilogue ’ Metadata ‘ llvm.loop.vectorize.followup_all ’ Metadata ‘ llvm.loop.unroll ’ ‘ llvm.loop.unroll.count ’ Metadata ‘ llvm.loop.unroll.disable ’ Metadata ‘ llvm.loop.unroll.runtime.disable ’ Metadata ‘ llvm.loop.unroll.enable ’ Metadata ‘ llvm.loop.unroll.full ’ Metadata ‘ llvm.loop.unroll.followup ’ Metadata ‘ llvm.loop.unroll.followup_remainder ’ Metadata ‘ llvm.loop.unroll_and_jam ’ ‘ llvm.loop.unroll_and_jam.count ’ Metadata ‘ llvm.loop.unroll_and_jam.disable ’ Metadata ‘ llvm.loop.unroll_and_jam.enable ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_outer ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_inner ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_remainder_outer ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_remainder_inner ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_all ’ Metadata ‘ llvm.loop.licm_versioning.disable ’ Metadata ‘ llvm.loop.distribute.enable ’ Metadata ‘ llvm.loop.distribute.followup_coincident ’ Metadata ‘ llvm.loop.distribute.followup_sequential ’ Metadata ‘ llvm.loop.distribute.followup_fallback ’ Metadata ‘ llvm.loop.distribute.followup_all ’ Metadata ‘ llvm.loop.isdistributed ’ Metadata ‘ llvm.loop.estimated_trip_count ’ Metadata ‘ llvm.licm.disable ’ Metadata ‘ llvm.access.group ’ Metadata ‘ llvm.loop.parallel_accesses ’ Metadata ‘ llvm.loop.mustprogress ’ Metadata ‘ irr_loop ’ Metadata ‘ invariant.group ’ Metadata ‘ type ’ Metadata ‘ callee_type ’ Metadata ‘ associated ’ Metadata ‘ prof ’ Metadata ‘ annotation ’ Metadata ‘ func_sanitize ’ Metadata ‘ kcfi_type ’ Metadata ‘ pcsections ’ Metadata ‘ memprof ’ Metadata ‘ callsite ’ Metadata ‘ noalias.addrspace ’ Metadata ‘ mmra ’ Metadata ‘ nofree ’ Metadata ‘ alloc_token ’ Metadata ‘ stack-protector ’ Metadata ‘ implicit.ref ’ Metadata Module Flags Metadata Synthesized Functions Module Flags Metadata Objective-C Garbage Collection Module Flags Metadata C type width Module Flags Metadata Stack Alignment Metadata Embedded Objects Names Metadata Automatic Linker Flags Named Metadata Dependent Libs Named Metadata ‘ llvm.errno.tbaa ’ Named Metadata ThinLTO Summary Module Path Summary Entry Global Value Summary Entry Function Summary Global Variable Summary Alias Summary Function Flags Calls Params Refs TypeIdInfo Type ID Summary Entry Intrinsic Global Variables The ‘ llvm.used ’ Global Variable The ‘ llvm.compiler.used ’ Global Variable The ‘ llvm.global_ctors ’ Global Variable The ‘ llvm.global_dtors ’ Global Variable Instruction Reference Terminator Instructions ‘ ret ’ Instruction ‘ br ’ Instruction ‘ switch ’ Instruction ‘ indirectbr ’ Instruction ‘ invoke ’ Instruction ‘ callbr ’ Instruction ‘ resume ’ Instruction ‘ catchswitch ’ Instruction ‘ catchret ’ Instruction ‘ cleanupret ’ Instruction ‘ unreachable ’ Instruction Unary Operations ‘ fneg ’ Instruction Binary Operations ‘ add ’ Instruction ‘ fadd ’ Instruction ‘ sub ’ Instruction ‘ fsub ’ Instruction ‘ mul ’ Instruction ‘ fmul ’ Instruction ‘ udiv ’ Instruction ‘ sdiv ’ Instruction ‘ fdiv ’ Instruction ‘ urem ’ Instruction ‘ srem ’ Instruction ‘ frem ’ Instruction Bitwise Binary Operations ‘ shl ’ Instruction ‘ lshr ’ Instruction ‘ ashr ’ Instruction ‘ and ’ Instruction ‘ or ’ Instruction ‘ xor ’ Instruction Vector Operations ‘ extractelement ’ Instruction ‘ insertelement ’ Instruction ‘ shufflevector ’ Instruction Aggregate Operations ‘ extractvalue ’ Instruction ‘ insertvalue ’ Instruction Memory Access and Addressing Operations ‘ alloca ’ Instruction ‘ load ’ Instruction ‘ store ’ Instruction ‘ fence ’ Instruction ‘ cmpxchg ’ Instruction ‘ atomicrmw ’ Instruction ‘ getelementptr ’ Instruction Conversion Operations ‘ trunc .. to ’ Instruction ‘ zext .. to ’ Instruction ‘ sext .. to ’ Instruction ‘ fptrunc .. to ’ Instruction ‘ fpext .. to ’ Instruction ‘ fptoui .. to ’ Instruction ‘ fptosi .. to ’ Instruction ‘ uitofp .. to ’ Instruction ‘ sitofp .. to ’ Instruction ‘ ptrtoint .. to ’ Instruction ‘ ptrtoaddr .. to ’ Instruction ‘ inttoptr .. to ’ Instruction ‘ bitcast .. to ’ Instruction ‘ addrspacecast .. to ’ Instruction Other Operations ‘ icmp ’ Instruction ‘ fcmp ’ Instruction ‘ phi ’ Instruction ‘ select ’ Instruction ‘ freeze ’ Instruction ‘ call ’ Instruction ‘ va_arg ’ Instruction ‘ landingpad ’ Instruction ‘ catchpad ’ Instruction ‘ cleanuppad ’ Instruction Debug Records Intrinsic Functions Variable Argument Handling Intrinsics ‘ llvm.va_start ’ Intrinsic ‘ llvm.va_end ’ Intrinsic ‘ llvm.va_copy ’ Intrinsic Accurate Garbage Collection Intrinsics ‘ llvm.gcroot ’ Intrinsic ‘ llvm.gcread ’ Intrinsic ‘ llvm.gcwrite ’ Intrinsic ‘ llvm.experimental.gc.statepoint ’ Intrinsic ‘ llvm.experimental.gc.result ’ Intrinsic ‘ llvm.experimental.gc.relocate ’ Intrinsic ‘ llvm.experimental.gc.get.pointer.base ’ Intrinsic ‘ llvm.experimental.gc.get.pointer.offset ’ Intrinsic Code Generator Intrinsics ‘ llvm.returnaddress ’ Intrinsic ‘ llvm.addressofreturnaddress ’ Intrinsic ‘ llvm.sponentry ’ Intrinsic ‘ llvm.stackaddress ’ Intrinsic ‘ llvm.frameaddress ’ Intrinsic ‘ llvm.swift.async.context.addr ’ Intrinsic ‘ llvm.localescape ’ and ‘ llvm.localrecover ’ Intrinsics ‘ llvm.seh.try.begin ’ and ‘ llvm.seh.try.end ’ Intrinsics ‘ llvm.seh.scope.begin ’ and ‘ llvm.seh.scope.end ’ Intrinsics ‘ llvm.read_register ’, ‘ llvm.read_volatile_register ’, and ‘ llvm.write_register ’ Intrinsics ‘ llvm.stacksave ’ Intrinsic ‘ llvm.stackrestore ’ Intrinsic ‘ llvm.get.dynamic.area.offset ’ Intrinsic ‘ llvm.prefetch ’ Intrinsic ‘ llvm.pcmarker ’ Intrinsic ‘ llvm.readcyclecounter ’ Intrinsic ‘ llvm.readsteadycounter ’ Intrinsic ‘ llvm.clear_cache ’ Intrinsic ‘ llvm.instrprof.increment ’ Intrinsic ‘ llvm.instrprof.increment.step ’ Intrinsic ‘ llvm.instrprof.callsite ’ Intrinsic ‘ llvm.instrprof.timestamp ’ Intrinsic ‘ llvm.instrprof.cover ’ Intrinsic ‘ llvm.instrprof.value.profile ’ Intrinsic ‘ llvm.instrprof.mcdc.parameters ’ Intrinsic ‘ llvm.instrprof.mcdc.tvbitmap.update ’ Intrinsic ‘ llvm.thread.pointer ’ Intrinsic ‘ llvm.call.preallocated.setup ’ Intrinsic ‘ llvm.call.preallocated.arg ’ Intrinsic ‘ llvm.call.preallocated.teardown ’ Intrinsic Standard C/C++ Library Intrinsics ‘ llvm.abs.* ’ Intrinsic ‘ llvm.smax.* ’ Intrinsic ‘ llvm.smin.* ’ Intrinsic ‘ llvm.umax.* ’ Intrinsic ‘ llvm.umin.* ’ Intrinsic ‘ llvm.scmp.* ’ Intrinsic ‘ llvm.ucmp.* ’ Intrinsic ‘ llvm.memcpy ’ Intrinsic ‘ llvm.memcpy.inline ’ Intrinsic ‘ llvm.memmove ’ Intrinsic ‘ llvm.memset.* ’ Intrinsics ‘ llvm.memset.inline ’ Intrinsic ‘ llvm.experimental.memset.pattern ’ Intrinsic ‘ llvm.sqrt.* ’ Intrinsic ‘ llvm.powi.* ’ Intrinsic ‘ llvm.sin.* ’ Intrinsic ‘ llvm.cos.* ’ Intrinsic ‘ llvm.tan.* ’ Intrinsic ‘ llvm.asin.* ’ Intrinsic ‘ llvm.acos.* ’ Intrinsic ‘ llvm.atan.* ’ Intrinsic ‘ llvm.atan2.* ’ Intrinsic ‘ llvm.sinh.* ’ Intrinsic ‘ llvm.cosh.* ’ Intrinsic ‘ llvm.tanh.* ’ Intrinsic ‘ llvm.sincos.* ’ Intrinsic ‘ llvm.sincospi.* ’ Intrinsic ‘ llvm.modf.* ’ Intrinsic ‘ llvm.pow.* ’ Intrinsic ‘ llvm.exp.* ’ Intrinsic ‘ llvm.exp2.* ’ Intrinsic ‘ llvm.exp10.* ’ Intrinsic ‘ llvm.ldexp.* ’ Intrinsic ‘ llvm.frexp.* ’ Intrinsic ‘ llvm.log.* ’ Intrinsic ‘ llvm.log10.* ’ Intrinsic ‘ llvm.log2.* ’ Intrinsic ‘ llvm.fma.* ’ Intrinsic ‘ llvm.fabs.* ’ Intrinsic ‘ llvm.min.* ’ Intrinsics Comparation ‘ llvm.minnum.* ’ Intrinsic ‘ llvm.maxnum.* ’ Intrinsic ‘ llvm.minimum.* ’ Intrinsic ‘ llvm.maximum.* ’ Intrinsic ‘ llvm.minimumnum.* ’ Intrinsic ‘ llvm.maximumnum.* ’ Intrinsic ‘ llvm.copysign.* ’ Intrinsic ‘ llvm.floor.* ’ Intrinsic ‘ llvm.ceil.* ’ Intrinsic ‘ llvm.trunc.* ’ Intrinsic ‘ llvm.rint.* ’ Intrinsic ‘ llvm.nearbyint.* ’ Intrinsic ‘ llvm.round.* ’ Intrinsic ‘ llvm.roundeven.* ’ Intrinsic ‘ llvm.lround.* ’ Intrinsic ‘ llvm.llround.* ’ Intrinsic ‘ llvm.lrint.* ’ Intrinsic ‘ llvm.llrint.* ’ Intrinsic Bit Manipulation Intrinsics ‘ llvm.bitreverse.* ’ Intrinsics ‘ llvm.bswap.* ’ Intrinsics ‘ llvm.ctpop.* ’ Intrinsic ‘ llvm.ctlz.* ’ Intrinsic ‘ llvm.cttz.* ’ Intrinsic ‘ llvm.fshl.* ’ Intrinsic ‘ llvm.fshr.* ’ Intrinsic ‘ llvm.clmul.* ’ Intrinsic Arithmetic with Overflow Intrinsics ‘ llvm.sadd.with.overflow.* ’ Intrinsics ‘ llvm.uadd.with.overflow.* ’ Intrinsics ‘ llvm.ssub.with.overflow.* ’ Intrinsics ‘ llvm.usub.with.overflow.* ’ Intrinsics ‘ llvm.smul.with.overflow.* ’ Intrinsics ‘ llvm.umul.with.overflow.* ’ Intrinsics Saturation Arithmetic Intrinsics ‘ llvm.sadd.sat.* ’ Intrinsics ‘ llvm.uadd.sat.* ’ Intrinsics ‘ llvm.ssub.sat.* ’ Intrinsics ‘ llvm.usub.sat.* ’ Intrinsics ‘ llvm.sshl.sat.* ’ Intrinsics ‘ llvm.ushl.sat.* ’ Intrinsics Fixed Point Arithmetic Intrinsics ‘ llvm.smul.fix.* ’ Intrinsics ‘ llvm.umul.fix.* ’ Intrinsics ‘ llvm.smul.fix.sat.* ’ Intrinsics ‘ llvm.umul.fix.sat.* ’ Intrinsics ‘ llvm.sdiv.fix.* ’ Intrinsics ‘ llvm.udiv.fix.* ’ Intrinsics ‘ llvm.sdiv.fix.sat.* ’ Intrinsics ‘ llvm.udiv.fix.sat.* ’ Intrinsics Specialized Arithmetic Intrinsics ‘ llvm.canonicalize.* ’ Intrinsic ‘ llvm.fmuladd.* ’ Intrinsic Hardware-Loop Intrinsics ‘ llvm.set.loop.iterations.* ’ Intrinsic ‘ llvm.start.loop.iterations.* ’ Intrinsic ‘ llvm.test.set.loop.iterations.* ’ Intrinsic ‘ llvm.test.start.loop.iterations.* ’ Intrinsic ‘ llvm.loop.decrement.reg.* ’ Intrinsic ‘ llvm.loop.decrement.* ’ Intrinsic Vector Reduction Intrinsics ‘ llvm.vector.reduce.add.* ’ Intrinsic ‘ llvm.vector.reduce.fadd.* ’ Intrinsic ‘ llvm.vector.reduce.mul.* ’ Intrinsic ‘ llvm.vector.reduce.fmul.* ’ Intrinsic ‘ llvm.vector.reduce.and.* ’ Intrinsic ‘ llvm.vector.reduce.or.* ’ Intrinsic ‘ llvm.vector.reduce.xor.* ’ Intrinsic ‘ llvm.vector.reduce.smax.* ’ Intrinsic ‘ llvm.vector.reduce.smin.* ’ Intrinsic ‘ llvm.vector.reduce.umax.* ’ Intrinsic ‘ llvm.vector.reduce.umin.* ’ Intrinsic ‘ llvm.vector.reduce.fmax.* ’ Intrinsic ‘ llvm.vector.reduce.fmin.* ’ Intrinsic ‘ llvm.vector.reduce.fmaximum.* ’ Intrinsic ‘ llvm.vector.reduce.fminimum.* ’ Intrinsic Vector Partial Reduction Intrinsics ‘ llvm.vector.partial.reduce.add.* ’ Intrinsic ‘ llvm.vector.partial.reduce.fadd.* ’ Intrinsic Vector Manipulation Intrinsics ‘ llvm.vector.insert ’ Intrinsic ‘ llvm.vector.extract ’ Intrinsic ‘ llvm.vector.reverse ’ Intrinsic ‘ llvm.vector.deinterleave2/3/4/5/6/7/8 ’ Intrinsic ‘ llvm.vector.interleave2/3/4/5/6/7/8 ’ Intrinsic ‘ llvm.vector.splice.left ’ Intrinsic ‘ llvm.vector.splice.right ’ Intrinsic ‘ llvm.stepvector ’ Intrinsic Experimental Vector Intrinsics ‘ llvm.experimental.cttz.elts ’ Intrinsic ‘ llvm.experimental.get.vector.length ’ Intrinsic ‘ llvm.experimental.vector.histogram.* ’ Intrinsic ‘ llvm.experimental.vector.extract.last.active ’ Intrinsic ‘ llvm.experimental.vector.compress.* ’ Intrinsics ‘ llvm.experimental.vector.match.* ’ Intrinsic Matrix Intrinsics ‘ llvm.matrix.transpose.* ’ Intrinsic ‘ llvm.matrix.multiply.* ’ Intrinsic ‘ llvm.matrix.column.major.load.* ’ Intrinsic ‘ llvm.matrix.column.major.store.* ’ Intrinsic Half Precision Floating-Point Intrinsics ‘ llvm.convert.to.fp16 ’ Intrinsic ‘ llvm.convert.from.fp16 ’ Intrinsic Saturating floating-point to integer conversions ‘ llvm.fptoui.sat.* ’ Intrinsic ‘ llvm.fptosi.sat.* ’ Intrinsic Floating-Point Conversion Intrinsics ‘ llvm.fptrunc.round ’ Intrinsic Convergence Intrinsics Debugger Intrinsics Exception Handling Intrinsics Pointer Authentication Intrinsics Trampoline Intrinsics ‘ llvm.init.trampoline ’ Intrinsic ‘ llvm.adjust.trampoline ’ Intrinsic Vector Predication Intrinsics Optimization Hint ‘ llvm.vp.select.* ’ Intrinsics ‘ llvm.vp.merge.* ’ Intrinsics ‘ llvm.vp.add.* ’ Intrinsics ‘ llvm.vp.sub.* ’ Intrinsics ‘ llvm.vp.mul.* ’ Intrinsics ‘ llvm.vp.sdiv.* ’ Intrinsics ‘ llvm.vp.udiv.* ’ Intrinsics ‘ llvm.vp.srem.* ’ Intrinsics ‘ llvm.vp.urem.* ’ Intrinsics ‘ llvm.vp.ashr.* ’ Intrinsics ‘ llvm.vp.lshr.* ’ Intrinsics ‘ llvm.vp.shl.* ’ Intrinsics ‘ llvm.vp.or.* ’ Intrinsics ‘ llvm.vp.and.* ’ Intrinsics ‘ llvm.vp.xor.* ’ Intrinsics ‘ llvm.vp.abs.* ’ Intrinsics ‘ llvm.vp.smax.* ’ Intrinsics ‘ llvm.vp.smin.* ’ Intrinsics ‘ llvm.vp.umax.* ’ Intrinsics ‘ llvm.vp.umin.* ’ Intrinsics ‘ llvm.vp.copysign.* ’ Intrinsics ‘ llvm.vp.minnum.* ’ Intrinsics ‘ llvm.vp.maxnum.* ’ Intrinsics ‘ llvm.vp.minimum.* ’ Intrinsics ‘ llvm.vp.maximum.* ’ Intrinsics ‘ llvm.vp.fadd.* ’ Intrinsics ‘ llvm.vp.fsub.* ’ Intrinsics ‘ llvm.vp.fmul.* ’ Intrinsics ‘ llvm.vp.fdiv.* ’ Intrinsics ‘ llvm.vp.frem.* ’ Intrinsics ‘ llvm.vp.fneg.* ’ Intrinsics ‘ llvm.vp.fabs.* ’ Intrinsics ‘ llvm.vp.sqrt.* ’ Intrinsics ‘ llvm.vp.fma.* ’ Intrinsics ‘ llvm.vp.fmuladd.* ’ Intrinsics ‘ llvm.vp.reduce.add.* ’ Intrinsics ‘ llvm.vp.reduce.fadd.* ’ Intrinsics ‘ llvm.vp.reduce.mul.* ’ Intrinsics ‘ llvm.vp.reduce.fmul.* ’ Intrinsics ‘ llvm.vp.reduce.and.* ’ Intrinsics ‘ llvm.vp.reduce.or.* ’ Intrinsics ‘ llvm.vp.reduce.xor.* ’ Intrinsics ‘ llvm.vp.reduce.smax.* ’ Intrinsics ‘ llvm.vp.reduce.smin.* ’ Intrinsics ‘ llvm.vp.reduce.umax.* ’ Intrinsics ‘ llvm.vp.reduce.umin.* ’ Intrinsics ‘ llvm.vp.reduce.fmax.* ’ Intrinsics ‘ llvm.vp.reduce.fmin.* ’ Intrinsics ‘ llvm.vp.reduce.fmaximum.* ’ Intrinsics ‘ llvm.vp.reduce.fminimum.* ’ Intrinsics ‘ llvm.get.active.lane.mask.* ’ Intrinsics ‘ llvm.loop.dependence.war.mask.* ’ Intrinsics ‘ llvm.loop.dependence.raw.mask.* ’ Intrinsics ‘ llvm.experimental.vp.splice ’ Intrinsic ‘ llvm.experimental.vp.reverse ’ Intrinsic ‘ llvm.vp.load ’ Intrinsic ‘ llvm.vp.load.ff ’ Intrinsic ‘ llvm.vp.store ’ Intrinsic ‘ llvm.experimental.vp.strided.load ’ Intrinsic ‘ llvm.experimental.vp.strided.store ’ Intrinsic ‘ llvm.vp.gather ’ Intrinsic ‘ llvm.vp.scatter ’ Intrinsic ‘ llvm.vp.trunc.* ’ Intrinsics ‘ llvm.vp.zext.* ’ Intrinsics ‘ llvm.vp.sext.* ’ Intrinsics ‘ llvm.vp.fptrunc.* ’ Intrinsics ‘ llvm.vp.fpext.* ’ Intrinsics ‘ llvm.vp.fptoui.* ’ Intrinsics ‘ llvm.vp.fptosi.* ’ Intrinsics ‘ llvm.vp.uitofp.* ’ Intrinsics ‘ llvm.vp.sitofp.* ’ Intrinsics ‘ llvm.vp.ptrtoint.* ’ Intrinsics ‘ llvm.vp.inttoptr.* ’ Intrinsics ‘ llvm.vp.fcmp.* ’ Intrinsics ‘ llvm.vp.icmp.* ’ Intrinsics ‘ llvm.vp.ceil.* ’ Intrinsics ‘ llvm.vp.floor.* ’ Intrinsics ‘ llvm.vp.rint.* ’ Intrinsics ‘ llvm.vp.nearbyint.* ’ Intrinsics ‘ llvm.vp.round.* ’ Intrinsics ‘ llvm.vp.roundeven.* ’ Intrinsics ‘ llvm.vp.roundtozero.* ’ Intrinsics ‘ llvm.vp.lrint.* ’ Intrinsics ‘ llvm.vp.llrint.* ’ Intrinsics ‘ llvm.vp.bitreverse.* ’ Intrinsics ‘ llvm.vp.bswap.* ’ Intrinsics ‘ llvm.vp.ctpop.* ’ Intrinsics ‘ llvm.vp.ctlz.* ’ Intrinsics ‘ llvm.vp.cttz.* ’ Intrinsics ‘ llvm.vp.cttz.elts.* ’ Intrinsics ‘ llvm.vp.sadd.sat.* ’ Intrinsics ‘ llvm.vp.uadd.sat.* ’ Intrinsics ‘ llvm.vp.ssub.sat.* ’ Intrinsics ‘ llvm.vp.usub.sat.* ’ Intrinsics ‘ llvm.vp.fshl.* ’ Intrinsics ‘ llvm.vp.fshr.* ’ Intrinsics ‘ llvm.vp.is.fpclass.* ’ Intrinsics Masked Vector Load and Store Intrinsics ‘ llvm.masked.load.* ’ Intrinsics ‘ llvm.masked.store.* ’ Intrinsics Masked Vector Gather and Scatter Intrinsics ‘ llvm.masked.gather.* ’ Intrinsics ‘ llvm.masked.scatter.* ’ Intrinsics Masked Vector Expanding Load and Compressing Store Intrinsics ‘ llvm.masked.expandload.* ’ Intrinsics ‘ llvm.masked.compressstore.* ’ Intrinsics Memory Use Markers ‘ llvm.lifetime.start ’ Intrinsic ‘ llvm.lifetime.end ’ Intrinsic ‘ llvm.invariant.start ’ Intrinsic ‘ llvm.invariant.end ’ Intrinsic ‘ llvm.launder.invariant.group ’ Intrinsic ‘ llvm.strip.invariant.group ’ Intrinsic Constrained Floating-Point Intrinsics ‘ llvm.experimental.constrained.fadd ’ Intrinsic ‘ llvm.experimental.constrained.fsub ’ Intrinsic ‘ llvm.experimental.constrained.fmul ’ Intrinsic ‘ llvm.experimental.constrained.fdiv ’ Intrinsic ‘ llvm.experimental.constrained.frem ’ Intrinsic ‘ llvm.experimental.constrained.fma ’ Intrinsic ‘ llvm.experimental.constrained.fptoui ’ Intrinsic ‘ llvm.experimental.constrained.fptosi ’ Intrinsic ‘ llvm.experimental.constrained.uitofp ’ Intrinsic ‘ llvm.experimental.constrained.sitofp ’ Intrinsic ‘ llvm.experimental.constrained.fptrunc ’ Intrinsic ‘ llvm.experimental.constrained.fpext ’ Intrinsic ‘ llvm.experimental.constrained.fcmp ’ and ‘ llvm.experimental.constrained.fcmps ’ Intrinsics ‘ llvm.experimental.constrained.fmuladd ’ Intrinsic Constrained libm-equivalent Intrinsics ‘ llvm.experimental.constrained.sqrt ’ Intrinsic ‘ llvm.experimental.constrained.pow ’ Intrinsic ‘ llvm.experimental.constrained.powi ’ Intrinsic ‘ llvm.experimental.constrained.ldexp ’ Intrinsic ‘ llvm.experimental.constrained.sin ’ Intrinsic ‘ llvm.experimental.constrained.cos ’ Intrinsic ‘ llvm.experimental.constrained.tan ’ Intrinsic ‘ llvm.experimental.constrained.asin ’ Intrinsic ‘ llvm.experimental.constrained.acos ’ Intrinsic ‘ llvm.experimental.constrained.atan ’ Intrinsic ‘ llvm.experimental.constrained.atan2 ’ Intrinsic ‘ llvm.experimental.constrained.sinh ’ Intrinsic ‘ llvm.experimental.constrained.cosh ’ Intrinsic ‘ llvm.experimental.constrained.tanh ’ Intrinsic ‘ llvm.experimental.constrained.exp ’ Intrinsic ‘ llvm.experimental.constrained.exp2 ’ Intrinsic ‘ llvm.experimental.constrained.log ’ Intrinsic ‘ llvm.experimental.constrained.log10 ’ Intrinsic ‘ llvm.experimental.constrained.log2 ’ Intrinsic ‘ llvm.experimental.constrained.rint ’ Intrinsic ‘ llvm.experimental.constrained.lrint ’ Intrinsic ‘ llvm.experimental.constrained.llrint ’ Intrinsic ‘ llvm.experimental.constrained.nearbyint ’ Intrinsic ‘ llvm.experimental.constrained.maxnum ’ Intrinsic ‘ llvm.experimental.constrained.minnum ’ Intrinsic ‘ llvm.experimental.constrained.maximum ’ Intrinsic ‘ llvm.experimental.constrained.minimum ’ Intrinsic ‘ llvm.experimental.constrained.ceil ’ Intrinsic ‘ llvm.experimental.constrained.floor ’ Intrinsic ‘ llvm.experimental.constrained.round ’ Intrinsic ‘ llvm.experimental.constrained.roundeven ’ Intrinsic ‘ llvm.experimental.constrained.lround ’ Intrinsic ‘ llvm.experimental.constrained.llround ’ Intrinsic ‘ llvm.experimental.constrained.trunc ’ Intrinsic ‘ llvm.experimental.noalias.scope.decl ’ Intrinsic Floating Point Environment Manipulation intrinsics ‘ llvm.get.rounding ’ Intrinsic ‘ llvm.set.rounding ’ Intrinsic ‘ llvm.get.fpenv ’ Intrinsic ‘ llvm.set.fpenv ’ Intrinsic ‘ llvm.reset.fpenv ’ Intrinsic ‘ llvm.get.fpmode ’ Intrinsic ‘ llvm.set.fpmode ’ Intrinsic ‘ llvm.reset.fpmode ’ Intrinsic Floating-Point Test Intrinsics ‘ llvm.is.fpclass ’ Intrinsic General Intrinsics ‘ llvm.var.annotation ’ Intrinsic ‘ llvm.ptr.annotation.* ’ Intrinsic ‘ llvm.annotation.* ’ Intrinsic ‘ llvm.codeview.annotation ’ Intrinsic ‘ llvm.trap ’ Intrinsic ‘ llvm.debugtrap ’ Intrinsic ‘ llvm.ubsantrap ’ Intrinsic ‘ llvm.stackprotector ’ Intrinsic ‘ llvm.stackguard ’ Intrinsic ‘ llvm.objectsize ’ Intrinsic ‘ llvm.expect ’ Intrinsic ‘ llvm.expect.with.probability ’ Intrinsic ‘ llvm.assume ’ Intrinsic ‘ llvm.ssa.copy ’ Intrinsic ‘ llvm.type.test ’ Intrinsic ‘ llvm.type.checked.load ’ Intrinsic ‘ llvm.type.checked.load.relative ’ Intrinsic ‘ llvm.arithmetic.fence ’ Intrinsic ‘ llvm.donothing ’ Intrinsic ‘ llvm.experimental.deoptimize ’ Intrinsic ‘ llvm.experimental.guard ’ Intrinsic ‘ llvm.experimental.widenable.condition ’ Intrinsic ‘ llvm.allow.ubsan.check ’ Intrinsic ‘ llvm.allow.runtime.check ’ Intrinsic ‘ llvm.load.relative ’ Intrinsic ‘ llvm.sideeffect ’ Intrinsic ‘ llvm.is.constant.* ’ Intrinsic ‘ llvm.ptrmask ’ Intrinsic ‘ llvm.threadlocal.address ’ Intrinsic ‘ llvm.vscale ’ Intrinsic ‘ llvm.fake.use ’ Intrinsic ‘ llvm.reloc.none ’ Intrinsic Stack Map Intrinsics Element Wise Atomic Memory Intrinsics ‘ llvm.memcpy.element.unordered.atomic ’ Intrinsic ‘ llvm.memmove.element.unordered.atomic ’ Intrinsic ‘ llvm.memset.element.unordered.atomic ’ Intrinsic Objective-C ARC Runtime Intrinsics ‘ llvm.objc.autorelease ’ Intrinsic ‘ llvm.objc.autoreleasePoolPop ’ Intrinsic ‘ llvm.objc.autoreleasePoolPush ’ Intrinsic ‘ llvm.objc.autoreleaseReturnValue ’ Intrinsic ‘ llvm.objc.copyWeak ’ Intrinsic ‘ llvm.objc.destroyWeak ’ Intrinsic ‘ llvm.objc.initWeak ’ Intrinsic ‘ llvm.objc.loadWeak ’ Intrinsic ‘ llvm.objc.loadWeakRetained ’ Intrinsic ‘ llvm.objc.moveWeak ’ Intrinsic ‘ llvm.objc.release ’ Intrinsic ‘ llvm.objc.retain ’ Intrinsic ‘ llvm.objc.retainAutorelease ’ Intrinsic ‘ llvm.objc.retainAutoreleaseReturnValue ’ Intrinsic ‘ llvm.objc.retainAutoreleasedReturnValue ’ Intrinsic ‘ llvm.objc.retainBlock ’ Intrinsic ‘ llvm.objc.storeStrong ’ Intrinsic ‘ llvm.objc.storeWeak ’ Intrinsic Preserving Debug Information Intrinsics ‘ llvm.preserve.array.access.index ’ Intrinsic ‘ llvm.preserve.union.access.index ’ Intrinsic ‘ llvm.preserve.struct.access.index ’ Intrinsic ‘ llvm.protected.field.ptr ’ Intrinsic Abstract ¶ This document is a reference manual for the LLVM assembly language. LLVM is a Static Single Assignment (SSA) based representation that provides type safety, low-level operations, flexibility, and the capability of representing ‘all’ high-level languages cleanly. It is the common code representation used throughout all phases of the LLVM compilation strategy. Introduction ¶ The LLVM code representation is designed to be used in three different forms: as an in-memory compiler IR, as an on-disk bitcode representation (suitable for fast loading by a Just-In-Time compiler), and as a human readable assembly language representation. This allows LLVM to provide a powerful intermediate representation for efficient compiler transformations and analysis, while providing a natural means to debug and visualize the transformations. The three different forms of LLVM are all equivalent. This document describes the human-readable representation and notation. The LLVM representation aims to be light-weight and low-level while being expressive, typed, and extensible at the same time. It aims to be a “universal IR” of sorts, by being at a low enough level that high-level ideas may be cleanly mapped to it (similar to how microprocessors are “universal IR’s”, allowing many source languages to be mapped to them). By providing type information, LLVM can be used as the target of optimizations: for example, through pointer analysis, it can be proven that a C automatic variable is never accessed outside of the current function, allowing it to be promoted to a simple SSA value instead of a memory location. Well-Formedness ¶ It is important to note that this document describes ‘well formed’ LLVM assembly language. There is a difference between what the parser accepts and what is considered ‘well formed’. For example, the following instruction is syntactically okay, but not well formed: %x = add i32 1 , %x because the definition of %x does not dominate all of its uses. The LLVM infrastructure provides a verification pass that may be used to verify that an LLVM module is well formed. This pass is automatically run by the parser after parsing input assembly and by the optimizer before it outputs bitcode. The violations pointed out by the verifier pass indicate bugs in transformation passes or input to the parser. Syntax ¶ Identifiers ¶ LLVM identifiers come in two basic types: global and local. Global identifiers (functions, global variables) begin with the '@' character. Local identifiers (register names, types) begin with the '%' character. Additionally, there are three different formats for identifiers, for different purposes: Named values are represented as a string of characters with their prefix. For example, %foo , @DivisionByZero , %a.really.long.identifier . The actual regular expression used is ‘ [%@][-a-zA-Z$._][-a-zA-Z$._0-9]* ’. Identifiers that require other characters in their names can be surrounded with quotes. Special characters may be escaped using "\xx" where xx is the ASCII code for the character in hexadecimal. In this way, any character can be used in a name value, even quotes themselves. The "\01" prefix can be used on global values to suppress mangling. Unnamed values are represented as an unsigned numeric value with their prefix. For example, %12 , @2 , %44 . Constants, which are described in the section Constants below. LLVM requires that values start with a prefix for two reasons: Compilers don’t need to worry about name clashes with reserved words, and the set of reserved words may be expanded in the future without penalty. Additionally, unnamed identifiers allow a compiler to quickly come up with a temporary variable without having to avoid symbol table conflicts. Reserved words in LLVM are very similar to reserved words in other languages. There are keywords for different opcodes (’ add ’, ‘ bitcast ’, ‘ ret ’, etc…), for primitive type names (’ void ’, ‘ i32 ’, etc…), and others. These reserved words cannot conflict with variable names, because none of them start with a prefix character ( '%' or '@' ). Here is an example of LLVM code to multiply the integer variable ‘ %X ’ by 8: The easy way: %result = mul i32 %X , 8 After strength reduction: %result = shl i32 %X , 3 And the hard way: %0 = add i32 %X , %X ; yields i32:%0 %1 = add i32 %0 , %0 / * yields i32: %1 * / %result = add i32 %1 , %1 This last way of multiplying %X by 8 illustrates several important lexical features of LLVM: Comments are delimited with a ‘ ; ’ and go until the end of line. Alternatively, comments can start with /* and terminate with */ . Unnamed temporaries are created when the result of a computation is not assigned to a named value. By default, unnamed temporaries are numbered sequentially (using a per-function incrementing counter, starting with 0). However, when explicitly specifying temporary numbers, it is allowed to skip over numbers. Note that basic blocks and unnamed function parameters are included in this numbering. For example, if the entry basic block is not given a label name and all function parameters are named, then it will get number 0. It also shows a convention that we follow in this document. When demonstrating instructions, we will follow an instruction with a comment that defines the type and name of value produced. String constants ¶ Strings in LLVM programs are delimited by " characters. Within a string, all bytes are treated literally with the exception of \ characters, which start escapes, and the first " character, which ends the string. There are two kinds of escapes. \\ represents a single \ character. \ followed by two hexadecimal characters (0-9, a-f, or A-F) represents the byte with the given value (e.g., \00 represents a null byte). To represent a " character, use \22 . ( \" will end the string with a trailing \ .) Newlines do not terminate string constants; strings can span multiple lines. The interpretation of string constants (e.g., their character encoding) depends on context. High Level Structure ¶ Module Structure ¶ LLVM programs are composed of Module ’s, each of which is a translation unit of the input programs. Each module consists of functions, global variables, and symbol table entries. Modules may be combined together with the LLVM linker, which merges function (and global variable) definitions, resolves forward declarations, and merges symbol table entries. Here is an example of the “hello world” module: ; Declare the string constant as a global constant. @.str = private unnamed_addr constant [ 13 x i8 ] c "hello world\0A\00" ; External declaration of the puts function declare i32 @puts ( ptr captures ( none )) nounwind ; Definition of main function define i32 @main () { ; Call puts function to write out the string to stdout. call i32 @puts ( ptr @.str ) ret i32 0 } ; Named metadata !0 = !{ i32 42 , null , !"string" } !foo = !{ !0 } This example is made up of a global variable named “ .str ”, an external declaration of the “ puts ” function, a function definition for “ main ” and named metadata “ foo ”. In general, a module is made up of a list of global values (where both functions and global variables are global values). Global values are represented by a pointer to a memory location (in this case, a pointer to an array of char, and a pointer to a function), and have one of the following linkage types . Linkage Types ¶ All Global Variables and Functions have one of the following types of linkage: private Global values with “ private ” linkage are only directly accessible by objects in the current module. In particular, linking code into a module with a private global value may cause the private to be renamed as necessary to avoid collisions. Because the symbol is private to the module, all references can be updated. This doesn’t show up in any symbol table in the object file. internal Similar to private, but the value shows as a local symbol ( STB_LOCAL in the case of ELF) in the object file. This corresponds to the notion of the ‘ static ’ keyword in C. available_externally Globals with “ available_externally ” linkage are never emitted into the object file corresponding to the LLVM module. From the linker’s perspective, an available_externally global is equivalent to an external declaration. They exist to allow inlining and other optimizations to take place given knowledge of the definition of the global, which is known to be somewhere outside the module. Globals with available_externally linkage are allowed to be discarded at will, and allow inlining and other optimizations. This linkage type is only allowed on definitions, not declarations. linkonce Globals with “ linkonce ” linkage are merged with other globals of the same name when linkage occurs. This can be used to implement some forms of inline functions, templates, or other code which must be generated in each translation unit that uses it, but where the body may be overridden with a more definitive definition later. Unreferenced linkonce globals are allowed to be discarded. Note that linkonce linkage does not actually allow the optimizer to inline the body of this function into callers because it doesn’t know if this definition of the function is the definitive definition within the program or whether it will be overridden by a stronger definition. To enable inlining and other optimizations, use “ linkonce_odr ” linkage. weak “ weak ” linkage has the same merging semantics as linkonce linkage, except that unreferenced globals with weak linkage may not be discarded. This is used for globals that are declared “weak” in C source code. common “ common ” linkage is most similar to “ weak ” linkage, but they are used for tentative definitions in C, such as “ int X; ” at global scope. Symbols with “ common ” linkage are merged in the same way as weak symbols , and they may not be deleted if unreferenced. common symbols may not have an explicit section, must have a zero initializer, and may not be marked ‘ constant ’. Functions and aliases may not have common linkage. appending “ appending ” linkage may only be applied to global variables of pointer to array type. When two global variables with appending linkage are linked together, the two global arrays are appended together. This is the LLVM, typesafe, equivalent of having the system linker append together “sections” with identical names when .o files are linked. Unfortunately this doesn’t correspond to any feature in .o files, so it can only be used for variables like llvm.global_ctors which llvm interprets specially. extern_weak The semantics of this linkage follow the ELF object file model: the symbol is weak until linked, if not linked, the symbol becomes null instead of being an undefined reference. linkonce_odr , weak_odr The odr suffix indicates that all globals defined with the given name are equivalent, along the lines of the C++ “one definition rule” (“ODR”). Informally, this means we can inline functions and fold loads of constants. Formally, use the following definition: when an odr function is called, one of the definitions is non-deterministically chosen to run. For odr variables, if any byte in the value is not equal in all initializers, that byte is a poison value . For aliases and ifuncs, apply the rule for the underlying function or variable. These linkage types are otherwise the same as their non- odr versions. external If none of the above identifiers are used, the global is externally visible, meaning that it participates in linkage and can be used to resolve external symbol references. It is illegal for a global variable or function declaration to have any linkage type other than external or extern_weak . Calling Conventions ¶ LLVM functions , calls and invokes can all have an optional calling convention specified for the call. The calling convention of any pair of dynamic caller/callee must match, or the behavior of the program is undefined. The following calling conventions are supported by LLVM, and more may be added in the future: “ ccc ” - The C calling convention This calling convention (the default if no other calling convention is specified) matches the target C calling conventions. This calling convention supports varargs function calls and tolerates some mismatch in the declared prototype and implemented declaration of the function (as does normal C). “ fastcc ” - The fast calling convention This calling convention attempts to make calls as fast as possible (e.g., by passing things in registers). This calling convention allows the target to use whatever tricks it wants to produce fast code for the target, without having to conform to an externally specified ABI (Application Binary Interface). Targets may use different implementations according to different features. In this case, a TTI interface useFastCCForInternalCall must return false when any caller functions and the callee belong to different implementations. Tail calls can only be optimized when this, the tailcc, the GHC or the HiPE convention is used. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition. “ coldcc ” - The cold calling convention This calling convention attempts to make code in the caller as efficient as possible under the assumption that the call is not commonly executed. As such, these calls often preserve all registers so that the call does not break any live ranges in the caller side. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition. Furthermore the inliner doesn’t consider such function calls for inlining. “ ghccc ” - GHC convention This calling convention has been implemented specifically for use by the Glasgow Haskell Compiler (GHC) . It passes everything in registers, going to extremes to achieve this by disabling callee save registers. This calling convention should not be used lightly but only for specific situations such as an alternative to the register pinning performance technique often used when implementing functional programming languages. At the moment only X86, AArch64, and RISCV support this convention. The following limitations exist: On X86-32 only up to 4 bit type parameters are supported. No floating-point types are supported. On X86-64 only up to 10 bit type parameters and 6 floating-point parameters are supported. On AArch64 only up to 4 32-bit floating-point parameters, 4 64-bit floating-point parameters, and 10 bit type parameters are supported. RISCV64 only supports up to 11 bit type parameters, 4 32-bit floating-point parameters, and 4 64-bit floating-point parameters. This calling convention supports tail call optimization but requires both the caller and callee to use it. “ cc 11 ” - The HiPE calling convention This calling convention has been implemented specifically for use by the High-Performance Erlang (HiPE) compiler, the native code compiler of the Ericsson’s Open Source Erlang/OTP system . It uses more registers for argument passing than the ordinary C calling convention and defines no callee-saved registers. The calling convention properly supports tail call optimization but requires that both the caller and the callee use it. It uses a register pinning mechanism, similar to GHC’s convention, for keeping frequently accessed runtime components pinned to specific hardware registers. At the moment only X86 supports this convention (both 32 and 64 bit). “ anyregcc ” - Dynamic calling convention for code patching This is a special convention that supports patching an arbitrary code sequence in place of a call site. This convention forces the call arguments into registers but allows them to be dynamically allocated. This can currently only be used with calls to llvm.experimental.patchpoint because only this intrinsic records the location of its arguments in a side table. See Stack maps and patch points in LLVM . “ preserve_mostcc ” - The PreserveMost calling convention This calling convention attempts to make the code in the caller as unintrusive as possible. This convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This alleviates the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn’t apply for values returned in callee-saved registers. On X86-64 the callee preserves all general purpose registers, except for R11 and return registers, if any. R11 can be used as a scratch register. The treatment of floating-point registers (XMMs/YMMs) matches the OS’s C calling convention: on most platforms, they are not preserved and need to be saved by the caller, but on Windows, xmm6-xmm15 are preserved. On AArch64 the callee preserves all general purpose registers, except X0-X8 and X16-X18. Not allowed with nest . On RISC-V the callee preserves x5-x31 except x6, x7 and x28 registers. On LoongArch the callee preserves r4-r31 except r12-r15 and r20-r21 registers. The idea behind this convention is to support calls to runtime functions that have a hot path and a cold path. The hot path is usually a small piece of code that doesn’t use many registers. The cold path might need to call out to another function and therefore only needs to preserve the caller-saved registers, which haven’t already been saved by the caller. The PreserveMost calling convention is very similar to the cold calling convention in terms of caller/callee-saved registers, but they are used for different types of function calls. coldcc is for function calls that are rarely executed, whereas preserve_mostcc function calls are intended to be on the hot path and definitely executed a lot. Furthermore preserve_mostcc doesn’t prevent the inliner from inlining the function call. This calling convention will be used by a future version of the Objective-C runtime and should therefore still be considered experimental at this time. Although this convention was created to optimize certain runtime calls to the Objective-C runtime, it is not limited to this runtime and might be used by other runtimes in the future too. The current implementation only supports X86-64, but the intention is to support more architectures in the future. “ preserve_allcc ” - The PreserveAll calling convention This calling convention attempts to make the code in the caller even less intrusive than the PreserveMost calling convention. This calling convention also behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This removes the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn’t apply for values returned in callee-saved registers. On X86-64 the callee preserves all general purpose registers, except for R11. R11 can be used as a scratch register. Furthermore it also preserves all floating-point registers (XMMs/YMMs). On AArch64 the callee preserves all general purpose registers, except X0-X8 and X16-X18. Furthermore it also preserves lower 128 bits of V8-V31 SIMD floating point registers. Not allowed with nest . The idea behind this convention is to support calls to runtime functions that don’t need to call out to any other functions. This calling convention, like the PreserveMost calling convention, will be used by a future version of the Objective-C runtime and should be considered experimental at this time. “ preserve_nonecc ” - The PreserveNone calling convention This calling convention doesn’t preserve any general registers. So all general registers are caller saved registers. It also uses all general registers to pass arguments. This attribute doesn’t impact non-general purpose registers (e.g., floating point registers, on X86 XMMs/YMMs). Non-general purpose registers still follow the standard C calling convention. Currently it is for x86_64 and AArch64 only. “ cxx_fast_tlscc ” - The CXX_FAST_TLS calling convention for access functions Clang generates an access function to access C++-style Thread Local Storage (TLS). The access function generally has an entry block, an exit block and an initialization block that is run at the first time. The entry and exit blocks can access a few TLS IR variables, each access will be lowered to a platform-specific sequence. This calling convention aims to minimize overhead in the caller by preserving as many registers as possible (all the registers that are preserved on the fast path, composed of the entry and exit blocks). This calling convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. Given that each platform has its own lowering sequence, hence its own set of preserved registers, we can’t use the existing PreserveMost . On X86-64 the callee preserves all general purpose registers, except for RDI and RAX. “ tailcc ” - Tail callable calling convention This calling convention ensures that calls in tail position will always be tail call optimized. This calling convention is equivalent to fastcc, except for an additional guarantee that tail calls will be produced whenever possible. Tail calls can only be optimized when this, the fastcc, the GHC or the HiPE convention is used. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition. “ swiftcc ” - This calling convention is used for Swift language. On X86-64 RCX and R8 are available for additional integer returns, and XMM2 and XMM3 are available for additional FP/vector returns. On iOS platforms, we use AAPCS-VFP calling convention. “ swifttailcc ” This calling convention is like swiftcc in most respects, but also the callee pops the argument area of the stack so that mandatory tail calls are possible as in tailcc . “ cfguard_checkcc ” - Windows Control Flow Guard (Check mechanism) This calling convention is used for the Control Flow Guard check function, calls to which can be inserted before indirect calls to check that the call target is a valid function address. The check function has no return value, but it will trigger an OS-level error if the address is not a valid target. The set of registers preserved by the check function, and the register containing the target address are architecture-specific. On X86 the target address is passed in ECX. On ARM the target address is passed in R0. On AArch64 the target address is passed in X15. “ cc <n> ” - Numbered convention Any calling convention may be specified by number, allowing target-specific calling conventions to be used. Target-specific calling conventions start at 64. More calling conventions can be added/defined on an as-needed basis, to support Pascal conventions or any other well-known target-independent convention. Visibility Styles ¶ All Global Variables and Functions have one of the following visibility styles: “ default ” - Default style On targets that use the ELF object file format, default visibility means that the declaration is visible to other modules and, in shared libraries, means that the declared entity may be overridden. On Darwin, default visibility means that the declaration is visible to other modules. On XCOFF, default visibility means no explicit visibility bit will be set and whether the symbol is visible (i.e “exported”) to other modules depends primarily on export lists provided to the linker. Default visibility corresponds to “external linkage” in the language. “ hidden ” - Hidd	2026-01-13T08:49:46
http://www.onlamp.com/pub/a/python/2002/10/17/biopython.html	Radar – O’Reilly Skip to main content For Enterprise For Government For Higher Ed For Individuals For Content Marketing For Enterprise For Government For Higher Ed For Individuals For Content Marketing Explore Skills Features All Features Verifiable Skills AI Academy Courses Certifications Interactive Learning Live Events Superstreams Answers Insights Reporting Radar Blog Buy Courses Close Search Plans Sign In Try Now O’Reilly Platform Toggle dark mode AI & ML Business Data Innovation Research Security Buy courses Get expert-led live training on exactly what you want to learn. Jan 13 Develop Self-Improving AI Agents with Reinforcement Learning Jan 13 Building AI Apps with Gemini and Google AI Studio Jan 13 6 Rules for Communicating with Management See all Try the O’Reilly learning platform With the O’Reilly learning platform, you get the resources and guidance to keep your skills sharp and stay ahead. Try it free for up to 14 days. Start trial Get the Radar Trends newsletter Your email Country - Select country - United States Afghanistan Albania Algeria Andorra Angola Antigua and Barbuda Argentina Armenia Aruba Australia Austria Azerbaijan The Bahamas Bahrain Bangladesh Barbados Belarus Belgium Belize Benin Bermuda Bhutan Bolivia Bosnia and Herzegovina Botswana Brazil Brunei Bulgaria Burkina Faso Burundi Cambodia Cameroon Canada Cape Verde Central African Republic Chad Chile People's Republic of China Colombia Comoros Congo, Republic of the Congo, Democratic Republic of the Cook Islands Costa Rica Côte d'Ivoire (Ivory Coast) Croatia Cuba Cyprus Czechia Denmark Djibouti Dominica Dominican Republic Ecuador Egypt El Salvador Equatorial Guinea Eritrea Estonia Eswatini (formerly Swaziland) Ethiopia Federated States of Micronesia Fiji Finland France Gabon The Gambia Georgia Germany Ghana Greece Grenada Guatemala Guinea Guinea-Bissau Guyana Haiti Honduras Hungary Iceland India Indonesia Iran Iraq Ireland Israel Italy Jamaica Japan Jordan Kazakhstan Kenya Kiribati Korea, Democratic People's Republic of Korea, Republic of Kuwait Kyrgyzstan Laos Latvia Lebanon Lesotho Liberia Libya Liechtenstein Lithuania Luxembourg Macedonia, Republic of Madagascar Malawi Malaysia Maldives Mali Malta Mauritania Mauritius Mexico Moldova Monaco Mongolia Montenegro Morocco Mozambique Myanmar Namibia Nauru Nepal Netherlands New Zealand Nicaragua Niger Nigeria Niue Norway Oman Pakistan Palestine, State of Panama Papua New Guinea Paraguay Peru Philippines Poland Portugal Qatar Romania Russia Rwanda Saint Kitts and Nevis Saint Lucia Saint Vincent and the Grenadines Samoa San Marino São Tomé and Príncipe Saudi Arabia Senegal Serbia Seychelles Sierra Leone Singapore Slovakia Slovenia Solomon Islands Somalia South Africa South Sudan Spain Sri Lanka Sudan Suriname Sweden Switzerland Syria Taiwan Tajikistan Tanzania Thailand Timor-Leste (East Timor) Togo Tonga Trinidad and Tobago Tunisia Turkey Turkmenistan Tuvalu Uganda Ukraine United Arab Emirates United Kingdom United States Uruguay Uzbekistan Vanuatu Vatican City Venezuela Vietnam Yemen Zambia Zimbabwe Subscribe Please read our privacy policy . Thank you for subscribing to the O’Reilly Radar Trends to Watch newsletter. article MCP Sampling: When Your Tools Need to Think By Angie Jones \| January 12, 2026 article AI & ML Signals for 2026 The tech trends we’re watching in the new year By Julie Baron \| January 9, 2026 article AI & ML The End of the Sync Script: Infrastructure as Intent How the Codex CLI and MCP turn the "stale CMDB" problem into a solved reasoning task—starting with Kubernetes By Abhinav Parmar, Sreeram Venkatasubramanian \| January 8, 2026 Latest Most Popular video The Agentic Fallacy: Fixing AI's Data Foundation with David Aronchick By O'Reilly \| January 9, 2026 article AI and the Next Economy By Tim O’Reilly \| January 7, 2026 video The Economics of AI Agents: Making Smart Choices in Design and Deployment with Nicole Königstein By O'Reilly \| January 6, 2026 article Radar Trends to Watch: January 2026 By Mike Loukides \| January 6, 2026 article MCPs for Developers Who Think They Don’t Need MCPs By Angie Jones \| January 5, 2026 video Explicit Memory Management with Angelina Yang—GenAI Prompt to Product Showcase By O'Reilly \| December 29, 2025 article How to Prevent Open Standards from Getting Captured Again By Sruly Rosenblat at Asimov’s Addendum \| December 23, 2025 video Running Better Meetings that Don’t Waste Time with Lena Reinhard and John Hartley By O'Reilly \| December 22, 2025 video Solving the Long Prompt Problem with Mike Taylor—GenAI Prompt to Product Showcase By O'Reilly \| December 19, 2025 video Context Engineering with LlamaIndex with Tuana Çelik—GenAI Prompt to Product Showcase By O'Reilly \| December 18, 2025 video Cut the Chit Chat with Artifacts with John Berryman—GenAI Prompt to Product Showcase By O'Reilly \| December 17, 2025 article If You’ve Never Broken It, You Don’t Really Know It By Tim O'Brien \| December 17, 2025 video Chrome DevTools MCP with Addy Osmani—GenAI Prompt to Product Showcase By O'Reilly \| December 16, 2025 video Resolving Incidents at the Speed of Agents with Ralph Bird—Key Moments from Security Superstream By O'Reilly \| December 15, 2025 article AI, MCP, and the Hidden Costs of Data Hoarding By Andrew Stellman \| December 15, 2025 video ML Model Persuasive Techniques with Ram Shankar Siva Kumar—Key Moments from Security Superstream By O'Reilly \| December 12, 2025 Load More Posts Follow us linkedin logo youtube logo About O’Reilly Teach/Write/Train Careers O’Reilly News Media Coverage Community Partners Affiliate Program Submit an RFP Diversity Content Sponsorship Support Contact Us Newsletters Privacy Policy AI Policy International Australia & New Zealand Japan Download the O’Reilly App Take O’Reilly with you and learn anywhere, anytime on your phone and tablet. Watch on Your Big Screen View all O’Reilly videos, virtual conferences, and live events on your home TV. Do not sell or share my personal information . © 2026, O’Reilly Media, Inc. All trademarks and registered trademarks appearing on oreilly.com are the property of their respective owners. Terms of Service • Privacy Policy • Editorial Independence • Modern Slavery Act Statement	2026-01-13T08:49:46
https://docs.python.org/3/whatsnew/3.14.html#whatsnew314-free-threaded-now-supported	What’s new in Python 3.14 — Python 3.14.2 documentation Theme Auto Light Dark Table of Contents What’s new in Python 3.14 Summary – Release highlights New features PEP 649 & PEP 749 : Deferred evaluation of annotations PEP 734 : Multiple interpreters in the standard library PEP 750 : Template string literals PEP 768 : Safe external debugger interface A new type of interpreter Free-threaded mode improvements Improved error messages PEP 784 : Zstandard support in the standard library Asyncio introspection capabilities Concurrent safe warnings control Other language changes Built-ins Command line and environment PEP 758: Allow except and except* expressions without brackets PEP 765: Control flow in finally blocks Incremental garbage collection Default interactive shell New modules Improved modules argparse ast asyncio calendar concurrent.futures configparser contextvars ctypes curses datetime decimal difflib dis errno faulthandler fnmatch fractions functools getopt getpass graphlib heapq hmac http imaplib inspect io json linecache logging.handlers math mimetypes multiprocessing operator os os.path pathlib pdb pickle platform pydoc re socket ssl struct symtable sys sys.monitoring sysconfig tarfile threading tkinter turtle types typing unicodedata unittest urllib uuid webbrowser zipfile Optimizations asyncio base64 bdb difflib gc io pathlib pdb textwrap uuid zlib Removed argparse ast asyncio email importlib.abc itertools pathlib pkgutil pty sqlite3 urllib Deprecated New deprecations Pending removal in Python 3.15 Pending removal in Python 3.16 Pending removal in Python 3.17 Pending removal in Python 3.18 Pending removal in Python 3.19 Pending removal in future versions CPython bytecode changes Pseudo-instructions C API changes Python configuration C API New features in the C API Limited C API changes Removed C APIs Deprecated C APIs Pending removal in Python 3.15 Pending removal in Python 3.16 Pending removal in Python 3.18 Pending removal in future versions Build changes build-details.json Discontinuation of PGP signatures Free-threaded Python is officially supported Binary releases for the experimental just-in-time compiler Porting to Python 3.14 Changes in the Python API Changes in annotations ( PEP 649 and PEP 749 ) Implications for annotated code Implications for readers of __annotations__ Related changes from __future__ import annotations Changes in the C API Notable changes in 3.14.1 Previous topic What’s New in Python Next topic What’s New In Python 3.13 This page Report a bug Show source Navigation index modules \| next \| previous \| Python » 3.14.2 Documentation » What’s New in Python » What’s new in Python 3.14 \| Theme Auto Light Dark \| What’s new in Python 3.14 ¶ Editors : Adam Turner and Hugo van Kemenade This article explains the new features in Python 3.14, compared to 3.13. Python 3.14 was released on 7 October 2025. For full details, see the changelog . See also PEP 745 – Python 3.14 release schedule Summary – Release highlights ¶ Python 3.14 is the latest stable release of the Python programming language, with a mix of changes to the language, the implementation, and the standard library. The biggest changes include template string literals , deferred evaluation of annotations , and support for subinterpreters in the standard library. The library changes include significantly improved capabilities for introspection in asyncio , support for Zstandard via a new compression.zstd module, syntax highlighting in the REPL, as well as the usual deprecations and removals, and improvements in user-friendliness and correctness. This article doesn’t attempt to provide a complete specification of all new features, but instead gives a convenient overview. For full details refer to the documentation, such as the Library Reference and Language Reference . To understand the complete implementation and design rationale for a change, refer to the PEP for a particular new feature; but note that PEPs usually are not kept up-to-date once a feature has been fully implemented. See Porting to Python 3.14 for guidance on upgrading from earlier versions of Python. Interpreter improvements: PEP 649 and PEP 749 : Deferred evaluation of annotations PEP 734 : Multiple interpreters in the standard library PEP 750 : Template strings PEP 758 : Allow except and except* expressions without brackets PEP 765 : Control flow in finally blocks PEP 768 : Safe external debugger interface for CPython A new type of interpreter Free-threaded mode improvements Improved error messages Incremental garbage collection Significant improvements in the standard library: PEP 784 : Zstandard support in the standard library Asyncio introspection capabilities Concurrent safe warnings control Syntax highlighting in the default interactive shell , and color output in several standard library CLIs C API improvements: PEP 741 : Python configuration C API Platform support: PEP 776 : Emscripten is now an officially supported platform , at tier 3 . Release changes: PEP 779 : Free-threaded Python is officially supported PEP 761 : PGP signatures have been discontinued for official releases Windows and macOS binary releases now support the experimental just-in-time compiler Binary releases for Android are now provided New features ¶ PEP 649 & PEP 749 : Deferred evaluation of annotations ¶ The annotations on functions, classes, and modules are no longer evaluated eagerly. Instead, annotations are stored in special-purpose annotate functions and evaluated only when necessary (except if from __future__ import annotations is used). This change is designed to improve performance and usability of annotations in Python in most circumstances. The runtime cost for defining annotations is minimized, but it remains possible to introspect annotations at runtime. It is no longer necessary to enclose annotations in strings if they contain forward references. The new annotationlib module provides tools for inspecting deferred annotations. Annotations may be evaluated in the VALUE format (which evaluates annotations to runtime values, similar to the behavior in earlier Python versions), the FORWARDREF format (which replaces undefined names with special markers), and the STRING format (which returns annotations as strings). This example shows how these formats behave: >>> from annotationlib import get_annotations , Format >>> def func ( arg : Undefined ): ... pass >>> get_annotations ( func , format = Format . VALUE ) Traceback (most recent call last): ... NameError : name 'Undefined' is not defined >>> get_annotations ( func , format = Format . FORWARDREF ) {'arg': ForwardRef('Undefined', owner=<function func at 0x...>)} >>> get_annotations ( func , format = Format . STRING ) {'arg': 'Undefined'} The porting section contains guidance on changes that may be needed due to these changes, though in the majority of cases, code will continue working as-is. (Contributed by Jelle Zijlstra in PEP 749 and gh-119180 ; PEP 649 was written by Larry Hastings.) See also PEP 649 Deferred Evaluation Of Annotations Using Descriptors PEP 749 Implementing PEP 649 PEP 734 : Multiple interpreters in the standard library ¶ The CPython runtime supports running multiple copies of Python in the same process simultaneously and has done so for over 20 years. Each of these separate copies is called an ‘interpreter’. However, the feature had been available only through the C-API . That limitation is removed in Python 3.14, with the new concurrent.interpreters module. There are at least two notable reasons why using multiple interpreters has significant benefits: they support a new (to Python), human-friendly concurrency model true multi-core parallelism For some use cases, concurrency in software improves efficiency and can simplify design, at a high level. At the same time, implementing and maintaining all but the simplest concurrency is often a struggle for the human brain. That especially applies to plain threads (for example, threading ), where all memory is shared between all threads. With multiple isolated interpreters, you can take advantage of a class of concurrency models, like Communicating Sequential Processes (CSP) or the actor model, that have found success in other programming languages, like Smalltalk, Erlang, Haskell, and Go. Think of multiple interpreters as threads but with opt-in sharing. Regarding multi-core parallelism: as of Python 3.12, interpreters are now sufficiently isolated from one another to be used in parallel (see PEP 684 ). This unlocks a variety of CPU-intensive use cases for Python that were limited by the GIL . Using multiple interpreters is similar in many ways to multiprocessing , in that they both provide isolated logical “processes” that can run in parallel, with no sharing by default. However, when using multiple interpreters, an application will use fewer system resources and will operate more efficiently (since it stays within the same process). Think of multiple interpreters as having the isolation of processes with the efficiency of threads. While the feature has been around for decades, multiple interpreters have not been used widely, due to low awareness and the lack of a standard library module. Consequently, they currently have several notable limitations, which are expected to improve significantly now that the feature is going mainstream. Current limitations: starting each interpreter has not been optimized yet each interpreter uses more memory than necessary (work continues on extensive internal sharing between interpreters) there aren’t many options yet for truly sharing objects or other data between interpreters (other than memoryview ) many third-party extension modules on PyPI are not yet compatible with multiple interpreters (all standard library extension modules are compatible) the approach to writing applications that use multiple isolated interpreters is mostly unfamiliar to Python users, for now The impact of these limitations will depend on future CPython improvements, how interpreters are used, and what the community solves through PyPI packages. Depending on the use case, the limitations may not have much impact, so try it out! Furthermore, future CPython releases will reduce or eliminate overhead and provide utilities that are less appropriate on PyPI. In the meantime, most of the limitations can also be addressed through extension modules, meaning PyPI packages can fill any gap for 3.14, and even back to 3.12 where interpreters were finally properly isolated and stopped sharing the GIL . Likewise, libraries on PyPI are expected to emerge for high-level abstractions on top of interpreters. Regarding extension modules, work is in progress to update some PyPI projects, as well as tools like Cython, pybind11, nanobind, and PyO3. The steps for isolating an extension module are found at Isolating Extension Modules . Isolating a module has a lot of overlap with what is required to support free-threading , so the ongoing work in the community in that area will help accelerate support for multiple interpreters. Also added in 3.14: concurrent.futures.InterpreterPoolExecutor . (Contributed by Eric Snow in gh-134939 .) See also PEP 734 PEP 750 : Template string literals ¶ Template strings are a new mechanism for custom string processing. They share the familiar syntax of f-strings but, unlike f-strings, return an object representing the static and interpolated parts of the string, instead of a simple str . To write a t-string, use a 't' prefix instead of an 'f' : >>> variety = 'Stilton' >>> template = t 'Try some {variety} cheese!' >>> type ( template ) <class 'string.templatelib.Template'> Template objects provide access to the static and interpolated (in curly braces) parts of a string before they are combined. Iterate over Template instances to access their parts in order: >>> list ( template ) ['Try some ', Interpolation('Stilton', 'variety', None, ''), ' cheese!'] It’s easy to write (or call) code to process Template instances. For example, here’s a function that renders static parts lowercase and Interpolation instances uppercase: from string.templatelib import Interpolation def lower_upper ( template ): """Render static parts lowercase and interpolations uppercase.""" parts = [] for part in template : if isinstance ( part , Interpolation ): parts . append ( str ( part . value ) . upper ()) else : parts . append ( part . lower ()) return '' . join ( parts ) name = 'Wenslydale' template = t 'Mister {name} ' assert lower_upper ( template ) == 'mister WENSLYDALE' Because Template instances distinguish between static strings and interpolations at runtime, they can be useful for sanitising user input. Writing a html() function that escapes user input in HTML is an exercise left to the reader! Template processing code can provide improved flexibility. For instance, a more advanced html() function could accept a dict of HTML attributes directly in the template: attributes = { 'src' : 'limburger.jpg' , 'alt' : 'lovely cheese' } template = t '<img {attributes} >' assert html ( template ) == '<img src="limburger.jpg" alt="lovely cheese" />' Of course, template processing code does not need to return a string-like result. An even more advanced html() could return a custom type representing a DOM-like structure. With t-strings in place, developers can write systems that sanitise SQL, make safe shell operations, improve logging, tackle modern ideas in web development (HTML, CSS, and so on), and implement lightweight custom business DSLs. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in gh-132661 .) See also PEP 750 . PEP 768 : Safe external debugger interface ¶ Python 3.14 introduces a zero-overhead debugging interface that allows debuggers and profilers to safely attach to running Python processes without stopping or restarting them. This is a significant enhancement to Python’s debugging capabilities, meaning that unsafe alternatives are no longer required. The new interface provides safe execution points for attaching debugger code without modifying the interpreter’s normal execution path or adding any overhead at runtime. Due to this, tools can now inspect and interact with Python applications in real-time, which is a crucial capability for high-availability systems and production environments. For convenience, this interface is implemented in the sys.remote_exec() function. For example: import sys from tempfile import NamedTemporaryFile with NamedTemporaryFile ( mode = 'w' , suffix = '.py' , delete = False ) as f : script_path = f . name f . write ( f 'import my_debugger; my_debugger.connect( { os . getpid () } )' ) # Execute in process with PID 1234 print ( 'Behold! An offering:' ) sys . remote_exec ( 1234 , script_path ) This function allows sending Python code to be executed in a target process at the next safe execution point. However, tool authors can also implement the protocol directly as described in the PEP, which details the underlying mechanisms used to safely attach to running processes. The debugging interface has been carefully designed with security in mind and includes several mechanisms to control access: A PYTHON_DISABLE_REMOTE_DEBUG environment variable. A -X disable-remote-debug command-line option. A --without-remote-debug configure flag to completely disable the feature at build time. (Contributed by Pablo Galindo Salgado, Matt Wozniski, and Ivona Stojanovic in gh-131591 .) See also PEP 768 . A new type of interpreter ¶ A new type of interpreter has been added to CPython. It uses tail calls between small C functions that implement individual Python opcodes, rather than one large C case statement. For certain newer compilers, this interpreter provides significantly better performance. Preliminary benchmarks suggest a geometric mean of 3-5% faster on the standard pyperformance benchmark suite, depending on platform and architecture. The baseline is Python 3.14 built with Clang 19, without this new interpreter. This interpreter currently only works with Clang 19 and newer on x86-64 and AArch64 architectures. However, a future release of GCC is expected to support this as well. This feature is opt-in for now. Enabling profile-guided optimization is highly recommendeded when using the new interpreter as it is the only configuration that has been tested and validated for improved performance. For further information, see --with-tail-call-interp . Note This is not to be confused with tail call optimization of Python functions, which is currently not implemented in CPython. This new interpreter type is an internal implementation detail of the CPython interpreter. It doesn’t change the visible behavior of Python programs at all. It can improve their performance, but doesn’t change anything else. (Contributed by Ken Jin in gh-128563 , with ideas on how to implement this in CPython by Mark Shannon, Garrett Gu, Haoran Xu, and Josh Haberman.) Free-threaded mode improvements ¶ CPython’s free-threaded mode ( PEP 703 ), initially added in 3.13, has been significantly improved in Python 3.14. The implementation described in PEP 703 has been finished, including C API changes, and temporary workarounds in the interpreter were replaced with more permanent solutions. The specializing adaptive interpreter ( PEP 659 ) is now enabled in free-threaded mode, which along with many other optimizations greatly improves its performance. The performance penalty on single-threaded code in free-threaded mode is now roughly 5-10%, depending on the platform and C compiler used. From Python 3.14, when compiling extension modules for the free-threaded build of CPython on Windows, the preprocessor variable Py_GIL_DISABLED now needs to be specified by the build backend, as it will no longer be determined automatically by the C compiler. For a running interpreter, the setting that was used at compile time can be found using sysconfig.get_config_var() . The new -X context_aware_warnings flag controls if concurrent safe warnings control is enabled. The flag defaults to true for the free-threaded build and false for the GIL-enabled build. A new thread_inherit_context flag has been added, which if enabled means that threads created with threading.Thread start with a copy of the Context() of the caller of start() . Most significantly, this makes the warning filtering context established by catch_warnings be “inherited” by threads (or asyncio tasks) started within that context. It also affects other modules that use context variables, such as the decimal context manager. This flag defaults to true for the free-threaded build and false for the GIL-enabled build. (Contributed by Sam Gross, Matt Page, Neil Schemenauer, Thomas Wouters, Donghee Na, Kirill Podoprigora, Ken Jin, Itamar Oren, Brett Simmers, Dino Viehland, Nathan Goldbaum, Ralf Gommers, Lysandros Nikolaou, Kumar Aditya, Edgar Margffoy, and many others. Some of these contributors are employed by Meta, which has continued to provide significant engineering resources to support this project.) Improved error messages ¶ The interpreter now provides helpful suggestions when it detects typos in Python keywords. When a word that closely resembles a Python keyword is encountered, the interpreter will suggest the correct keyword in the error message. This feature helps programmers quickly identify and fix common typing mistakes. For example: >>> whille True : ... pass Traceback (most recent call last): File "<stdin>" , line 1 whille True : ^^^^^^ SyntaxError : invalid syntax. Did you mean 'while'? While the feature focuses on the most common cases, some variations of misspellings may still result in regular syntax errors. (Contributed by Pablo Galindo in gh-132449 .) elif statements that follow an else block now have a specific error message. (Contributed by Steele Farnsworth in gh-129902 .) >>> if who == "me" : ... print ( "It's me!" ) ... else : ... print ( "It's not me!" ) ... elif who is None : ... print ( "Who is it?" ) File "<stdin>", line 5 elif who is None: ^^^^ SyntaxError: 'elif' block follows an 'else' block If a statement is passed to the Conditional expressions after else , or one of pass , break , or continue is passed before if , then the error message highlights where the expression is required. (Contributed by Sergey Miryanov in gh-129515 .) >>> x = 1 if True else pass Traceback (most recent call last): File "<string>" , line 1 x = 1 if True else pass ^^^^ SyntaxError : expected expression after 'else', but statement is given >>> x = continue if True else break Traceback (most recent call last): File "<string>" , line 1 x = continue if True else break ^^^^^^^^ SyntaxError : expected expression before 'if', but statement is given When incorrectly closed strings are detected, the error message suggests that the string may be intended to be part of the string. (Contributed by Pablo Galindo in gh-88535 .) >>> "The interesting object " The important object " is very important" Traceback (most recent call last): SyntaxError : invalid syntax. Is this intended to be part of the string? When strings have incompatible prefixes, the error now shows which prefixes are incompatible. (Contributed by Nikita Sobolev in gh-133197 .) >>> ub 'abc' File "<python-input-0>" , line 1 ub 'abc' ^^ SyntaxError : 'u' and 'b' prefixes are incompatible Improved error messages when using as with incompatible targets in: Imports: import ... as ... From imports: from ... import ... as ... Except handlers: except ... as ... Pattern-match cases: case ... as ... (Contributed by Nikita Sobolev in gh-123539 , gh-123562 , and gh-123440 .) Improved error message when trying to add an instance of an unhashable type to a dict or set . (Contributed by CF Bolz-Tereick and Victor Stinner in gh-132828 .) >>> s = set () >>> s . add ({ 'pages' : 12 , 'grade' : 'A' }) Traceback (most recent call last): File "<python-input-1>" , line 1 , in <module> s . add ({ 'pages' : 12 , 'grade' : 'A' }) ~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ TypeError : cannot use 'dict' as a set element (unhashable type: 'dict') >>> d = {} >>> l = [ 1 , 2 , 3 ] >>> d [ l ] = 12 Traceback (most recent call last): File "<python-input-4>" , line 1 , in <module> d [ l ] = 12 ~^^^ TypeError : cannot use 'list' as a dict key (unhashable type: 'list') Improved error message when an object supporting the synchronous context manager protocol is entered using async with instead of with , and vice versa for the asynchronous context manager protocol. (Contributed by Bénédikt Tran in gh-128398 .) PEP 784 : Zstandard support in the standard library ¶ The new compression package contains modules compression.lzma , compression.bz2 , compression.gzip and compression.zlib which re-export the lzma , bz2 , gzip and zlib modules respectively. The new import names under compression are the preferred names for importing these compression modules from Python 3.14. However, the existing modules names have not been deprecated. Any deprecation or removal of the existing compression modules will occur no sooner than five years after the release of 3.14. The new compression.zstd module provides compression and decompression APIs for the Zstandard format via bindings to Meta’s zstd library . Zstandard is a widely adopted, highly efficient, and fast compression format. In addition to the APIs introduced in compression.zstd , support for reading and writing Zstandard compressed archives has been added to the tarfile , zipfile , and shutil modules. Here’s an example of using the new module to compress some data: from compression import zstd import math data = str ( math . pi ) . encode () * 20 compressed = zstd . compress ( data ) ratio = len ( compressed ) / len ( data ) print ( f "Achieved compression ratio of { ratio } " ) As can be seen, the API is similar to the APIs of the lzma and bz2 modules. (Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in gh-132983 .) See also PEP 784 . Asyncio introspection capabilities ¶ Added a new command-line interface to inspect running Python processes using asynchronous tasks, available via python -m asyncio ps PID or python -m asyncio pstree PID . The ps subcommand inspects the given process ID (PID) and displays information about currently running asyncio tasks. It outputs a task table: a flat listing of all tasks, their names, their coroutine stacks, and which tasks are awaiting them. The pstree subcommand fetches the same information, but instead renders a visual async call tree, showing coroutine relationships in a hierarchical format. This command is particularly useful for debugging long-running or stuck asynchronous programs. It can help developers quickly identify where a program is blocked, what tasks are pending, and how coroutines are chained together. For example given this code: import asyncio async def play_track ( track ): await asyncio . sleep ( 5 ) print ( f '🎵 Finished: { track } ' ) async def play_album ( name , tracks ): async with asyncio . TaskGroup () as tg : for track in tracks : tg . create_task ( play_track ( track ), name = track ) async def main (): async with asyncio . TaskGroup () as tg : tg . create_task ( play_album ( 'Sundowning' , [ 'TNDNBTG' , 'Levitate' ]), name = 'Sundowning' ) tg . create_task ( play_album ( 'TMBTE' , [ 'DYWTYLM' , 'Aqua Regia' ]), name = 'TMBTE' ) if __name__ == '__main__' : asyncio . run ( main ()) Executing the new tool on the running process will yield a table like this: python -m asyncio ps 12345 tid task id task name coroutine stack awaiter chain awaiter name awaiter id ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 1935500 0x7fc930c18050 Task-1 TaskGroup._aexit -> TaskGroup.__aexit__ -> main 0x0 1935500 0x7fc930c18230 Sundowning TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> main Task-1 0x7fc930c18050 1935500 0x7fc93173fa50 TMBTE TaskGroup._aexit -> TaskGroup.__aexit__ -> album TaskGroup._aexit -> TaskGroup.__aexit__ -> main Task-1 0x7fc930c18050 1935500 0x7fc93173fdf0 TNDNBTG sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album Sundowning 0x7fc930c18230 1935500 0x7fc930d32510 Levitate sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album Sundowning 0x7fc930c18230 1935500 0x7fc930d32890 DYWTYLM sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album TMBTE 0x7fc93173fa50 1935500 0x7fc93161ec30 Aqua Regia sleep -> play TaskGroup._aexit -> TaskGroup.__aexit__ -> album TMBTE 0x7fc93173fa50 or a tree like this: python -m asyncio pstree 12345 └── ( T ) Task-1 └── main example.py:13 └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 ├── ( T ) Sundowning │ └── album example.py:8 │ └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 │ └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 │ ├── ( T ) TNDNBTG │ │ └── play example.py:4 │ │ └── sleep Lib/asyncio/tasks.py:702 │ └── ( T ) Levitate │ └── play example.py:4 │ └── sleep Lib/asyncio/tasks.py:702 └── ( T ) TMBTE └── album example.py:8 └── TaskGroup.__aexit__ Lib/asyncio/taskgroups.py:72 └── TaskGroup._aexit Lib/asyncio/taskgroups.py:121 ├── ( T ) DYWTYLM │ └── play example.py:4 │ └── sleep Lib/asyncio/tasks.py:702 └── ( T ) Aqua Regia └── play example.py:4 └── sleep Lib/asyncio/tasks.py:702 If a cycle is detected in the async await graph (which could indicate a programming issue), the tool raises an error and lists the cycle paths that prevent tree construction: python -m asyncio pstree 12345 ERROR: await-graph contains cycles - cannot print a tree! cycle: Task-2 → Task-3 → Task-2 (Contributed by Pablo Galindo, Łukasz Langa, Yury Selivanov, and Marta Gomez Macias in gh-91048 .) Concurrent safe warnings control ¶ The warnings.catch_warnings context manager will now optionally use a context variable for warning filters. This is enabled by setting the context_aware_warnings flag, either with the -X command-line option or an environment variable. This gives predictable warnings control when using catch_warnings combined with multiple threads or asynchronous tasks. The flag defaults to true for the free-threaded build and false for the GIL-enabled build. (Contributed by Neil Schemenauer and Kumar Aditya in gh-130010 .) Other language changes ¶ All Windows code pages are now supported as ‘cpXXX’ codecs on Windows. (Contributed by Serhiy Storchaka in gh-123803 .) Implement mixed-mode arithmetic rules combining real and complex numbers as specified by the C standard since C99. (Contributed by Sergey B Kirpichev in gh-69639 .) More syntax errors are now detected regardless of optimisation and the -O command-line option. This includes writes to __debug__ , incorrect use of await , and asynchronous comprehensions outside asynchronous functions. For example, python -O -c 'assert (__debug__ := 1)' or python -O -c 'assert await 1' now produce SyntaxError s. (Contributed by Irit Katriel and Jelle Zijlstra in gh-122245 & gh-121637 .) When subclassing a pure C type, the C slots for the new type are no longer replaced with a wrapped version on class creation if they are not explicitly overridden in the subclass. (Contributed by Tomasz Pytel in gh-132284 .) Built-ins ¶ The bytes.fromhex() and bytearray.fromhex() methods now accept ASCII bytes and bytes-like objects . (Contributed by Daniel Pope in gh-129349 .) Add class methods float.from_number() and complex.from_number() to convert a number to float or complex type correspondingly. They raise a TypeError if the argument is not a real number. (Contributed by Serhiy Storchaka in gh-84978 .) Support underscore and comma as thousands separators in the fractional part for floating-point presentation types of the new-style string formatting (with format() or f-strings ). (Contributed by Sergey B Kirpichev in gh-87790 .) The int() function no longer delegates to __trunc__() . Classes that want to support conversion to int() must implement either __int__() or __index__() . (Contributed by Mark Dickinson in gh-119743 .) The map() function now has an optional keyword-only strict flag like zip() to check that all the iterables are of equal length. (Contributed by Wannes Boeykens in gh-119793 .) The memoryview type now supports subscription, making it a generic type . (Contributed by Brian Schubert in gh-126012 .) Using NotImplemented in a boolean context will now raise a TypeError . This has raised a DeprecationWarning since Python 3.9. (Contributed by Jelle Zijlstra in gh-118767 .) Three-argument pow() now tries calling __rpow__() if necessary. Previously it was only called in two-argument pow() and the binary power operator. (Contributed by Serhiy Storchaka in gh-130104 .) super objects are now copyable and pickleable . (Contributed by Serhiy Storchaka in gh-125767 .) Command line and environment ¶ The import time flag can now track modules that are already loaded (‘cached’), via the new -X importtime=2 . When such a module is imported, the self and cumulative times are replaced by the string cached . Values above 2 for -X importtime are now reserved for future use. (Contributed by Noah Kim and Adam Turner in gh-118655 .) The command-line option -c now automatically dedents its code argument before execution. The auto-dedentation behavior mirrors textwrap.dedent() . (Contributed by Jon Crall and Steven Sun in gh-103998 .) -J is no longer a reserved flag for Jython , and now has no special meaning. (Contributed by Adam Turner in gh-133336 .) PEP 758: Allow except and except* expressions without brackets ¶ The except and except* expressions now allow brackets to be omitted when there are multiple exception types and the as clause is not used. For example: try : connect_to_server () except TimeoutError , ConnectionRefusedError : print ( 'The network has ceased to be!' ) (Contributed by Pablo Galindo and Brett Cannon in PEP 758 and gh-131831 .) PEP 765: Control flow in finally blocks ¶ The compiler now emits a SyntaxWarning when a return , break , or continue statement have the effect of leaving a finally block. This change is specified in PEP 765 . In situations where this change is inconvenient (such as those where the warnings are redundant due to code linting), the warning filter can be used to turn off all syntax warnings by adding ignore::SyntaxWarning as a filter. This can be specified in combination with a filter that converts other warnings to errors (for example, passing -Werror -Wignore::SyntaxWarning as CLI options, or setting PYTHONWARNINGS=error,ignore::SyntaxWarning ). Note that applying such a filter at runtime using the warnings module will only suppress the warning in code that is compiled after the filter is adjusted. Code that is compiled prior to the filter adjustment (for example, when a module is imported) will still emit the syntax warning. (Contributed by Irit Katriel in gh-130080 .) Incremental garbage collection ¶ The cycle garbage collector is now incremental. This means that maximum pause times are reduced by an order of magnitude or more for larger heaps. There are now only two generations: young and old. When gc.collect() is not called directly, the GC is invoked a little less frequently. When invoked, it collects the young generation and an increment of the old generation, instead of collecting one or more generations. The behavior of gc.collect() changes slightly: gc.collect(1) : Performs an increment of garbage collection, rather than collecting generation 1. Other calls to gc.collect() are unchanged. (Contributed by Mark Shannon in gh-108362 .) Default interactive shell ¶ The default interactive shell now highlights Python syntax. The feature is enabled by default, save if PYTHON_BASIC_REPL or any other environment variable that disables colour is set. See Controlling color for details. The default color theme for syntax highlighting strives for good contrast and exclusively uses the 4-bit VGA standard ANSI color codes for maximum compatibility. The theme can be customized using an experimental API _colorize.set_theme() . This can be called interactively or in the PYTHONSTARTUP script. Note that this function has no stability guarantees, and may change or be removed. (Contributed by Łukasz Langa in gh-131507 .) The default interactive shell now supports import auto-completion. This means that typing import co and pressing <Tab> will suggest modules starting with co . Similarly, typing from concurrent import i will suggest submodules of concurrent starting with i . Note that autocompletion of module attributes is not currently supported. (Contributed by Tomas Roun in gh-69605 .) New modules ¶ annotationlib : For introspecting annotations . See PEP 749 for more details. (Contributed by Jelle Zijlstra in gh-119180 .) compression (including compression.zstd ): A package for compression-related modules, including a new module to support the Zstandard compression format. See PEP 784 for more details. (Contributed by Emma Harper Smith, Adam Turner, Gregory P. Smith, Tomas Roun, Victor Stinner, and Rogdham in gh-132983 .) concurrent.interpreters : Support for multiple interpreters in the standard library. See PEP 734 for more details. (Contributed by Eric Snow in gh-134939 .) string.templatelib : Support for template string literals (t-strings). See PEP 750 for more details. (Contributed by Jim Baker, Guido van Rossum, Paul Everitt, Koudai Aono, Lysandros Nikolaou, Dave Peck, Adam Turner, Jelle Zijlstra, Bénédikt Tran, and Pablo Galindo Salgado in gh-132661 .) Improved modules ¶ argparse ¶ The default value of the program name for argparse.ArgumentParser now reflects the way the Python interpreter was instructed to find the __main__ module code. (Contributed by Serhiy Storchaka and Alyssa Coghlan in gh-66436 .) Introduced the optional suggest_on_error parameter to argparse.ArgumentParser , enabling suggestions for argument choices and subparser names if mistyped by the user. (Contributed by Savannah Ostrowski in gh-124456 .) Enable color for help text, which can be disabled with the optional color parameter to argparse.ArgumentParser . This can also be controlled by environment variables . (Contributed by Hugo van Kemenade in gh-130645 .) ast ¶ Add compare() , a function for comparing two ASTs. (Contributed by Batuhan Taskaya and Jeremy Hylton in gh-60191 .) Add support for copy.replace() for AST nodes. (Contributed by Bénédikt Tran in gh-121141 .) Docstrings are now removed from an optimized AST in optimization level 2. (Contributed by Irit Katriel in gh-123958 .) The repr() output for AST nodes now includes more information. (Contributed by Tomas Roun in gh-116022 .) When called with an AST as input, the parse() function now always verifies that the root node type is appropriate. (Contributed by Irit Katriel in gh-130139 .) Add new options to the command-line interface: --feature-version , --optimize , and --show-empty . (Contributed by Semyon Moroz in gh-133367 .) asyncio ¶ The function and methods named create_task() now take an arbitrary list of keyword arguments. All keyword arguments are passed to the Task constructor or the custom task factory. (See set_task_factory() for details.) The name and context keyword arguments are no longer special; the name should now be set using the name keyword argument of the factory, and context may be None . This affects the following function and methods: asyncio.create_task() , asyncio.loop.create_task() , asyncio.TaskGroup.create_task() . (Contributed by Thomas Grainger in gh-128307 .) There are two new utility functions for introspecting and printing a program’s call graph: capture_call_graph() and print_call_graph() . See Asyncio introspection capabilities for more details. (Contributed by Yury Selivanov, Pablo Galindo Salgado, and Łukasz Langa in gh-91048 .) calendar ¶ By default, today’s date is highlighted in color in calendar ’s command-line text output. This can be controlled by environment variables . (Contributed by Hugo van Kemenade in gh-128317 .) concurrent.futures ¶ Add a new executor class, InterpreterPoolExecutor , which exposes multiple Python interpreters in the same process (‘subinterpreters’) to Python code. This uses a pool of independent Python interpreters to execute calls asynchronously. This is separate from the new interpreters module introduced by PEP 734 . (Contributed by Eric Snow in gh-124548 .) On Unix platforms other than macOS, ‘forkserver’ is now the default start method for ProcessPoolExecutor (replacing ‘fork’ ). This change does not affect Windows or macOS, where ‘spawn’ remains the default start method. If the threading incompatible fork method is required, you must explicitly request it by supplying a multiprocessing context mp_context to ProcessPoolExecutor . See forkserver restrictions for information and differences with the fork method and how this change may affect existing code with mutable global shared variables and/or shared objects that can not be automatically pickled . (Contributed by Gregory P. Smith in gh-84559 .) Add two new methods to ProcessPoolExecutor , terminate_workers() and kill_workers() , as ways to terminate or kill all living worker processes in the given pool. (Contributed by Charles Machalow in gh-130849 .) Add the optional buffersize parameter to Executor.map to limit the number of submitted tasks whose results have not yet been yielded. If the buffer is full, iteration over the iterables pauses until a result is yielded from the buffer. (Contributed by Enzo Bonnal and Josh Rosenberg in gh-74028 .) configparser ¶ configparser will no longer write config files it cannot read, to improve security. Attempting to write() keys containing delimiters or beginning with the section header pattern will raise an InvalidWriteError . (Contributed by Jacob Lincoln in gh-129270 .) contextvars ¶ Support the context manager protocol for Token objects. (Contributed by Andrew Svetlov in gh-129889 .) ctypes ¶ The layout of bit fields in Structure and Union objects is now a closer match to platform defaults (GCC/Clang or MSVC). In particular, fields no longer overlap. (Contributed by Matthias Görgens in gh-97702 .) The Structure._layout_ class attribute can now be set to help match a non-default ABI. (Contributed by Petr Viktorin in gh-97702 .) The class of Structure / Union field descriptors is now available as CField , and has new attributes to aid debugging and introspection. (Contributed by Petr Viktorin in gh-128715 .) On Windows, the COMError exception is now public. (Contributed by Jun Komoda in gh-126686 .) On Windows, the CopyComPointer() function is now public. (Contributed by Jun Komoda in gh-127275 .) Add memoryview_at() , a function to create a memoryview object that refers to the supplied pointer and length. This works like ctypes.string_at() except it avoids a buffer copy, and is typically useful when implementing pure Python callback functions that are passed dynamically-sized buffers. (Contributed by Rian Hunter in gh-112018 .) Complex types, c_float_complex , c_double_complex , and c_longdouble_complex , are now available if both the compiler and the libffi library support complex C types. (Contributed by Sergey B Kirpichev in gh-61103 .) Add ctypes.util.dllist() for listing the shared libraries loaded by the current process. (Contributed by Brian Ward in gh-119349 .) Move ctypes.POINTER() types cache from a global internal cache ( _pointer_type_cache ) to the _CData.__pointer_type__ attribute of the corresponding ctypes types. This will stop the cache from growing without limits in some situations. (Contributed by Sergey Miryanov in gh-100926 .) The py_object type now supports subscription, making it a generic type . (Contributed by Brian Schubert in gh-132168 .) ctypes now supports free-threading builds . (Contributed by Kumar Aditya and Peter Bierma in gh-127945 .) curses ¶ Add the assume_default_colors() function, a refinement of the use_default_colors() function which allows changing the color pair 0 . (Contributed by Serhiy Storchaka in gh-133139 .) datetime ¶ Add the strptime() method to the datetime.date and datetime.time classes. (Contributed by Wannes Boeykens in gh-41431 .) decimal ¶ Add Decimal.from_number() as an alternative constructor for Decimal . (Contributed by Serhiy Storchaka in gh-121798 .) Expose IEEEContext() to support creation of contexts corresponding to the IEEE 754 (2008) decimal interchange formats. (Contributed by Sergey B Kirpichev in gh-53032 .) difflib ¶ Comparison pages with highlighted changes generated by the HtmlDiff class now support ‘dark mode’. (Contributed by Jiahao Li in gh-129939 .) dis ¶ Add support for rendering full source location information of instructions , rather than only the line number. This feature is added to the following interfaces via the show_positions keyword argument: dis.Bytecode dis.dis() dis.distb() dis.disassemble() This feature is also exposed via dis --show-positions . (Contributed by Bénédikt Tran in gh-123165 .) Add the dis --specialized command-line option to show specialized bytecode. (Contributed by Bénédikt Tran in gh-127413 .) errno ¶ Add the EHWPOISON error code constant. (Contributed by James Roy in gh-126585 .) faulthandler ¶ Add support for printing the C stack trace on systems that support it via the new dump_c_stack() function or via the c_stack argument in faulthandler.enable() . (Contributed by Peter Bierma in gh-127604 .) fnmatch ¶ Add filterfalse() , a function to reject names matching a given pattern. (Contributed by Bénédikt Tran in gh-74598 .) fractions ¶ A Fraction object may now be constructed from any object with the as_integer_ratio() method. (Contributed by Serhiy Storchaka in gh-82017 .) Add Fraction.from_number() as an alternative constructor for Fraction . (Contributed by Serhiy Storchaka in gh-121797 .) functools ¶ Add the Placeholder sentinel. This may be used with the partial() or partialmethod() functions to reserve a place for positional arguments in the returned partial object . (Contributed by Dominykas Grigonis in gh-119127 .) Allow the initial parameter of reduce() to be passed as a keyword argument. (Contributed by Sayandip Dutta in gh-125916 .) getopt ¶ Add support for options with optional arguments. (Contributed by Serhiy Storchaka in gh-126374 .) Add support for returning intermixed options and non-option arguments in order. (Contributed by Serhiy Storchaka in gh-126390 .) getpass ¶ Support keyboard feedback in the getpass() function via the keyword-only optional argument echo_char . Placeholder characters are rendered whenever a character is entered, and removed when a character is deleted. (Contributed by Semyon Moroz in gh-77065 .) graphlib ¶ Allow TopologicalSorter.prepare() to be called more than once as long as sorting has not started. (Contributed by Daniel Pope in gh-130914 .) heapq ¶ The heapq module has improved support for working with max-heaps, via the following new functions: heapify_max() heappush_max() heappop_max() heapreplace_max() heappushpop_max() hmac ¶ Add a built-in implementation for HMAC ( RFC 2104 ) using formally verified code from the HACL* project. This implementation is used as a fallback when the OpenSSL implementation of HMAC is not available. (Contributed by Bénédikt Tran in gh-99108 .) http ¶ Directory lists and error pages generated by the http.server module allow the browser to apply its default dark mode. (Contributed by Yorik Hansen in gh-123430 .) The http.server module now supports serving over HTTPS using the http.server.HTTPSServer class. This functionality is exposed by the command-line interface ( python -m http.server ) through the following options: --tls-cert <path> : Path to the TLS certificate file. --tls-key <path> : Optional path to the private key file. --tls-password-file <path> : Optional path to the password file for the private key. (Contributed by Semyon Moroz in gh-85162 .) imaplib ¶ Add IMAP4.idle() , implementing the IMAP4 IDLE command as defined in RFC 2177 . (Contributed by Forest in gh-55454 .) inspect ¶ signature() takes a new argument annotation_format to control the annotationlib.Format used for representing annotations. (Contributed by Jelle Zijlstra in gh-101552 .) Signature.format() takes a new argument unquote_annotations . If true, string annotations are displayed without surrounding quotes. (Contributed by Jelle Zijlstra in gh-101552 .) Add function ispackage() to determine whether an object is a package or not. (Contributed by Zhikang Yan in gh-125634 .) io ¶ Reading text from a non-blocking stream with read may now raise a BlockingIOError if the operation cannot immediately return bytes. (Contributed by Giovanni Siragusa in gh-109523 .) Add the Reader and Writer protocols as simpler alternatives to the pseudo-protocols typing.IO , typing.TextIO , and typing.BinaryIO . (Contributed by Sebastian Rittau in gh-127648 .) json ¶ Add exception notes for JSON serialization errors that allow identifying the source of the error. (Contributed by Serhiy Storchaka in gh-122163 .) Allow using the json module as a script using the -m switch: python -m json . This is now preferred to python -m json.tool , which is soft deprecated . See the JSON command-line interface documentation. (Contributed by Trey Hunner in gh-122873 .) By default, the output of the JSON command-line interface is highlighted in color. This can be controlled by environment variables . (Contributed by Tomas Roun in gh-131952 .) linecache ¶ getline() can now retrieve source code for frozen modules. (Contributed by Tian Gao in gh-131638 .) logging.handlers ¶ QueueListener objects now support the context manager protocol. (Contributed by Charles Machalow in gh-132106 .) QueueListener.start now raises a RuntimeError if the listener is already started. (Contributed by Charles Machalow in gh-132106 .) math ¶ Added more detailed error messages for domain errors in the module. (Contributed by Charlie Zhao and Sergey B Kirpichev in gh-101410 .) mimetypes ¶ Add a public command-line for the module, invoked via python -m mimetypes . (Contributed by Oleg Iarygin and Hugo van Kemenade in gh-93096 .) Add several new MIME types based on RFCs and common usage: Microsoft and RFC 8081 MIME types for fonts Embedded OpenType: application/vnd.ms-fontobject OpenType Layout (OTF) font/otf TrueType: font/ttf WOFF 1.0 font/woff WOFF 2.0 font/woff2 RFC 9559	2026-01-13T08:49:46
https://open.forem.com/emma-suntech	emmma - Open Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account Open Forem Close Follow User actions emmma I am from China Location 中国 Joined Joined on Sep 10, 2025 Pronouns led lover More info about @emma-suntech Badges 2 Week Community Wellness Streak Keep the community conversation going! Post at least 2 comments for 2 straight weeks and unlock the 4 Week Badge. Got it Close 1 Week Community Wellness Streak For actively engaging with the community by posting at least 2 comments in a single week. Got it Close Post 8 posts published Comment 6 comments written Tag 4 tags followed LED strip lighting is a distributed system (and long runs will humble you) emmma emmma emmma Follow Jan 7 LED strip lighting is a distributed system (and long runs will humble you) # hardware # learning # networking Comments Add Comment 2 min read Want to connect with emmma? Create an account to connect with emmma. You can also sign in below to proceed if you already have an account. Create Account Already have an account? Sign in What I Wish I Knew Before My First LED Strip Install: Light Diffusion + Power Planning emmma emmma emmma Follow Jan 6 What I Wish I Knew Before My First LED Strip Install: Light Diffusion + Power Planning # beginners # design # hardware Comments Add Comment 3 min read Battling Winter Darkness: How Better Lighting Saved My Productivity (No Ceiling Lights Allowed) emmma emmma emmma Follow Dec 16 '25 Battling Winter Darkness: How Better Lighting Saved My Productivity (No Ceiling Lights Allowed) # hardware # productivity # beginners Comments 1 comment 1 min read Lighting Is More Than Brightness: Practical Lessons from a Small Project emmma emmma emmma Follow Dec 15 '25 Lighting Is More Than Brightness: Practical Lessons from a Small Project # led # webdev # ai # beginners 1 reaction Comments 2 comments 1 min read Turning My Room into a Cozy Light Space: DIY LED Strip Setup & Lessons Learned emmma emmma emmma Follow Dec 10 '25 Turning My Room into a Cozy Light Space: DIY LED Strip Setup & Lessons Learned # design # diy # led 1 reaction Comments 1 comment 2 min read Simulation of Natural Convection + Radiative Coupling Heat Dissipation for High-Power LED Arrays using OpenFOAM emmma emmma emmma Follow Dec 8 '25 Simulation of Natural Convection + Radiative Coupling Heat Dissipation for High-Power LED Arrays using OpenFOAM # beginners # led # thermal 1 reaction Comments 1 comment 2 min read I Replaced All My “Smart” Lights with Dumb LEDs — And Finally Slept Through the Night emmma emmma emmma Follow Dec 2 '25 I Replaced All My “Smart” Lights with Dumb LEDs — And Finally Slept Through the Night # led # sleep 2 reactions Comments 1 comment 2 min read After a "click", I witnessed the magic of light emmma emmma emmma Follow Nov 27 '25 After a "click", I witnessed the magic of light # light # llighting # beginners # design Comments 2 comments 1 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV Open Forem — A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . Open Forem © 2016 - 2026. Where all the other conversations belong Log in Create account	2026-01-13T08:49:46
https://www.codecademy.com/learn/learn-python-3	Learn Python 3 \| Codecademy Skip to Content Loading menu bar Loading menu bar Search Search Course Learn Python 3 Learn the basics of Python 3.12, one of the most powerful, versatile, and in-demand programming languages today. 4.6 4.58 out of 5 stars 11,894 ratings Diagonal B Regular This course includes AI assistance for guided coding help Projects to apply new skills Quizzes to test your knowledge A certificate of completion Start 3,203,156 learners enrolled Diagonal B Regular This course includes AI assistance for guided coding help Projects to apply new skills Quizzes to test your knowledge A certificate of completion Skill level Beginner Time to complete Average based on combined completion rates — individual pacing in lessons, projects, and quizzes may vary 24 hours Projects 14 Prerequisites None About this course If you’re looking for a programming language that’s flexible and easy to read, try learning Python. It’s one of the most popular languages today, and programming in Python is used for everything from web and software development to data science and analytics to quality assurance. Skills you'll gain Write Python 3 programs Simplify the code you write Take your skills off-platform Preview Syllabus 14 lessons • 14 projects • 13 quizzes Expand all sections 1 Hello World Get started with Python syntax in this lesson and then create a point of sale system for a furniture store! 2 Control Flow Learn how to build control flow into your python code by including if, else, and elif statements. Expect to learn all you need to know about boolean variables and logical operators. 3 Lists Learn about lists, a data structure in Python used to store ordered groups of data. 4 Loops Loops are structures that let you repeat Python code over and over. Learn how to read loops and write them to solve your own problems. 5 Functions Learn about code reuse with Python functions. Apply that knowledge to create functions for famous physics formulas. 6 Python: Code Challenges (Optional) Optional code challenge to test your Python knowledge! 7 Strings Learn all about the Python string object. Figure out how to automatically create, rearrange, reassign, disassemble, and reassemble blocks of text! Certificate of completion available with Plus or Pro Earn a certificate of completion and showcase your accomplishment on your resume or LinkedIn. Show all 13 modules Start The platform Hands-on learning AI-assisted learning Make progress faster with our AI Learning Assistant, a tool that automatically understands your current course, instructions, and solution code — and gives you instant, personalized feedback. Real-world projects Take what you're learning into the real world. Choose from guided projects that help you solidify new concepts — or test yourself with independent projects designed to build your portfolio. Job-readiness checker See how well your skills and experience meet the requirements for jobs you're interested in. AI generates a personalized report to show you how ready you are for your dream job and where to improve to qualify for a role. Interview simulator Use AI to identify strengths and get personalized, actionable feedback to improve your interviewing skills. Easily see what's needed to improve your skills — no matter what stage you're at in your career. Assessments Test new skills as you learn them so you can better understand and apply new concepts. You'll also see which topics need more review and get practice recommendations to continue to improve. Explore features Projects in this course practice Project Receipts for Lovely Loveseats Keep receipts for your lovely loveseats. Programming is a treat with this sweet suite of feats! Use strings and numbers to save a catalog of furniture, then perform concatenation and math calculations to create a receipt. practice Project Block Letters Display your initials on screen in block characters to create an ASCII art. practice Project Magic 8-Ball We’ve learned about and explored a powerful tool in Python — control flow! It’s so powerful, in fact, that it can be used to tell someone’s fortune. Diagonal A Dense Meet the creator of the course Meet the full team Checker Dense Alisha Grama Senior Instructional Designer, Computer Science at Codecademy Alisha is a Senior Instructional Designer in the computer science domain at Codecademy. Alisha majored in Computer Science and minored in Ethics at the University of Rochester, where she gained experience as a Teaching Assistant. Before joining Codecademy, she taught STEM concepts to secondary students, including as the Lead Algebra Teacher at a Brooklyn charter school. Meet the full team Grid Regular Grid Regular Earn a certificate of completion Show your network you've done the work by earning a certificate of completion for each course or path you finish. Show proof Receive a certificate that demonstrates you've completed a course or path. Build a collection The more courses and paths you complete, the more certificates you collect. Share with your network Easily add certificates of completion to your LinkedIn profile to share your accomplishments. Learn Python 3 course ratings and reviews 4.6 4.58 out of 5 stars 11,894 ratings 5 stars 67% 4 stars 27% 3 stars 5% 2 stars 1% 1 star 1% Checker Dense Awesome course, understandable from the beginner and able to guide you step-by-step into using python for real stuff, not just for academic knowledge. LM Verified Learner Checker Dense Interactive and fun, concepts separated into nice and manageable chunks, so the the learning at no point feels like a chore and the next goal is always within reach. Matago L. Verified Learner Checker Dense The course was very well made. All concepts were explained very clearly and I really appreciate lot of examples and interactive elements. The pace of the course was slower which is ideal for beginners. I recommend to everyone who wants to get started in programming. Jana P. Verified Learner Our learners work at Google Logo Meta Logo Apple Logo EA Logo Amazon Logo IBM Logo Microsoft Logo Reddit Logo Spotify Logo Uber Logo YouTube Logo Instagram Logo Frequently asked questions about Python 3 What is Python 3? Python is a powerful and flexible general-purpose language with many applications. Python 3 is the latest version of the language, and it’s great for new and seasoned developers alike. In fact, it’s one of the most popular programming languages in the world. What is Python 3 used for? What kind of jobs can Python 3 get me? Why is Python so popular as a first coding language? What do I need to know before learning Python? Is there a Python 1 and 2? Should I Learn Python? Stephan Miller Jun 2, 2021 If you’re debating on whether or not you should learn Python, the answer is probably yes. As any developer will attest, it’s a great addition to almost any tech stack — and it consistently ranks highly among the most popularly used programming languages. Python’s popularity stems largely from its power and versatility. Below, we’ll explore the reasons behind Python’s popularity and its various applications to help you decide whether or not the language is right for you. Continue reading Join over 50 million learners and start Learn Python 3 today! Start Looking for something else? Related resources Article What is Python? What is Python, and what can it do? Article Python Syntax Guide for Beginners Learn Python syntax with this beginner-friendly guide. Understand Python indentation, print statements, variables, comments, user input, and more with examples. Article How to Build a Python Script: A Beginner’s Guide to Python Scripting Learn scripting and how to build Python scripts from scratch. Set up your environment, structure your code, run the script, and explore real examples with tips to get started. Related courses and paths Free course Python for Programmers An introduction to the basic syntax and fundamentals of Python for experienced programmers. Checker Dense Intermediate. Intermediate 3 hours 3 hours Free course Learn Python 2 Learn the basics of the world's fastest growing and most popular programming language used by software engineers, analysts, data scientists, and machine learning engineers alike. Checker Dense Beginner Friendly. Beginner Friendly 17 hours 17 hours Free course Learn the Basics of Programming with Codecademy This course is for new programmers who aren't sure what they want to learn about. Take this course to jumpstart your learning journey! Checker Dense Beginner Friendly. Beginner Friendly 1 hour 1 hour Browse more topics Cloud computing 3,012,667 learners enrolled DevOps 2,446,823 learners enrolled Python 4,305,778 learners enrolled Data engineering 2,889,621 learners enrolled IT 3,154,689 learners enrolled AI 2,563,116 learners enrolled Data analytics 3,208,882 learners enrolled Data science 5,322,830 learners enrolled Code foundations 8,529,406 learners enrolled View full catalog Checker Dense Unlock additional features with a paid plan Practice Projects Guided projects that help you solidify the skills and concepts you're learning. Assessments Auto-graded quizzes and immediate feedback help you reinforce your skills as you learn. Certificate of Completion Earn a document to prove you've completed a course or path that you can share with your network. See pricing and plans Company About Careers Affiliates Partnerships Resources Articles Blog Cheatsheets Code challenges Docs Projects Videos Workspaces Support Help Center Resources Articles Blog Cheatsheets Code challenges Docs Projects Videos Workspaces Support Help Center Plans For individuals For students For business Discounts Community Visit community Code Crew Events Learner Stories Refer a friend Codecademy from Skillsoft Codecademy from Skillsoft Subjects AI Cloud computing Code foundations Computer science Cybersecurity Data analytics Data science Data visualization Developer tools DevOps Game development IT Machine learning Math Mobile development Web design Web development Languages Bash C C++ C# Go HTML & CSS Java JavaScript Kotlin PHP Python R Ruby SQL Swift Career building Career paths Career Center Interview prep Professional certification Bootcamps — Full catalog Beta content Roadmap Mobile Mobile Privacy Policy Cookie Policy Do Not Sell My Personal Information Terms Made with ❤️ in NYC © 2026 Codecademy	2026-01-13T08:49:46
https://forem.com/t/jokes/page/8	jokes Page 8 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close jokes Follow Hide plz post the lols Create Post submission guidelines no spam don't be offensive (sexist, racist, homophobic, crude, etc.), the DEV code of conduct is still in place! make the jokes programming related-ish Older #jokes posts 5 6 7 8 9 10 11 12 13 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Apr 1 '24 Meme Monday # discuss # jokes # watercooler # mememonday 42 reactions Comments 26 comments 1 min read A Coder's Hilarious Journey Through Syntax Errors 01:13 Sukhpinder Singh Sukhpinder Singh Sukhpinder Singh Follow for C# Programming Apr 5 '24 A Coder's Hilarious Journey Through Syntax Errors # jokes # youtube # comedy # community 17 reactions Comments 6 comments 2 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Mar 25 '24 Meme Monday # discuss # watercooler # jokes 30 reactions Comments 24 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Mar 11 '24 Meme Monday # jokes # watercooler # discuss 32 reactions Comments 68 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Mar 18 '24 Meme Monday # watercooler # discuss # jokes 24 reactions Comments 27 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Mar 4 '24 Meme Monday # discuss # jokes # watercooler 29 reactions Comments 55 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Feb 26 '24 Meme Monday # discuss # watercooler # jokes 41 reactions Comments 54 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Feb 19 '24 Meme Monday # discuss # watercooler # jokes 47 reactions Comments 59 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Feb 12 '24 Meme Monday # discuss # jokes # watercooler 32 reactions Comments 50 comments 1 min read T-Shirt Tuesday OpenSource OpenSource OpenSource Follow for Webcrumbs May 14 '24 T-Shirt Tuesday # discuss # watercololer # jokes 28 reactions Comments 17 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Feb 5 '24 Meme Monday # discuss # watercooler # jokes 48 reactions Comments 66 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jan 29 '24 Meme Monday # discuss # watercooler # jokes 43 reactions Comments 85 comments 1 min read How to improve your GitHub vanity metrics FAST Jean-Michel 🕵🏻‍♂️ Fayard Jean-Michel 🕵🏻‍♂️ Fayard Jean-Michel 🕵🏻‍♂️ Fayard Follow Jan 29 '24 How to improve your GitHub vanity metrics FAST # showdev # career # watercooler # jokes 41 reactions Comments 9 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jan 22 '24 Meme Monday # discuss # watercooler # jokes 36 reactions Comments 48 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jan 15 '24 Meme Monday # discuss # watercooler # jokes 50 reactions Comments 119 comments 1 min read Stoic Driven Development Michael Z Michael Z Michael Z Follow Jan 25 '24 Stoic Driven Development # jokes # codequality # productivity 14 reactions Comments 1 comment 3 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jan 8 '24 Meme Monday # discuss # watercooler # jokes 25 reactions Comments 32 comments 1 min read What is Black Friday? Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Matt Ellen-Tsivintzeli Follow Jan 8 '24 What is Black Friday? # watercooler # discuss # jokes Comments 4 comments 1 min read Where is Meme Monday in 2024? LC LC LC Follow Jan 9 '24 Where is Meme Monday in 2024? # discuss # watercooler # jokes 2 reactions Comments 3 comments 1 min read Meme Monday (Holiday themed?) Ben Halpern Ben Halpern Ben Halpern Follow Dec 25 '23 Meme Monday (Holiday themed?) # discuss # watercooler # jokes 17 reactions Comments 23 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Dec 18 '23 Meme Monday # discuss # watercooler # jokes 21 reactions Comments 25 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Dec 11 '23 Meme Monday # discuss # watercooler # jokes 22 reactions Comments 18 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Dec 4 '23 Meme Monday # discuss # watercooler # jokes 31 reactions Comments 19 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Nov 27 '23 Meme Monday # discuss # watercooler # jokes 37 reactions Comments 33 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Nov 20 '23 Meme Monday # discuss # watercooler # jokes 42 reactions Comments 36 comments 1 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:47
https://discuss.opensource.org/t/seeking-brief-perspectives-from-contributors-on-ethics-of-open-source-commercialization-student-research/1346	Seeking brief perspectives from contributors on ethics of open-source commercialization (student research) - General - OSI Discuss OSI Discuss Seeking brief perspectives from contributors on ethics of open-source commercialization (student research) General Aquafire January 5, 2026, 2:07pm 1 Hello everyone, My name is Aasrith, and I’m a IB Career Path student conducting a research project on the ethics of open-source software commercialization. I’m specifically exploring whether companies have an ethical responsibility to contribute back when they monetize open-source projects. I’m not asking for technical support — only short ethical perspectives from developers or contributors who are willing to share their views. Even 1–2 sentences would be incredibly helpful. Any responses can remain anonymous and would be cited as personal communication for academic purposes only. If you are also willing to complete a Microsoft form, please do as it would much more helpful for my project. Open source software survey – Fill out form Thank you for your time, and thank you for contributing to the Godot ecosystem. 1 Like Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://opensource.org/license/apsl-2-0	Apple Public Source License 2.0 – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Non-Reusable Apple Public Source License 2.0 Version 2.0 Submitted: August 6, 2003 Submitter: Ernest Pabhakar SPDX short identifier: APSL-2.0 Steward: Apple Link to license steward's version Please read this License carefully before downloading this software. By downloading or using this software, you are agreeing to be bound by the terms of this License. If you do not or cannot agree to the terms of this License, please do not download or use the software. 1. General; Definitions. This License applies to any program or other work which Apple Computer, Inc. (“Apple”) makes publicly available and which contains a notice placed by Apple identifying such program or work as “Original Code” and stating that it is subject to the terms of this Apple Public Source License version 2.0 (“License”). As used in this License: 1.1 “Applicable Patent Rights” mean: (a) in the case where Apple is the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to Apple and (ii) that cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce and/or distribute the Original Code without infringement; and (b) in the case where You are the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to You and (ii) that cover subject matter in Your Modifications, taken alone or in combination with Original Code. 1.2 “Contributor” means any person or entity that creates or contributes to the creation of Modifications. 1.3 “Covered Code” means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof. 1.4 “Externally Deploy” means: (a) to sublicense, distribute or otherwise make Covered Code available, directly or indirectly, to anyone other than You; and/or (b) to use Covered Code, alone or as part of a Larger Work, in any way to provide a service, including but not limited to delivery of content, through electronic communication with a client other than You. 1.5 “Larger Work” means a work which combines Covered Code or portions thereof with code not governed by the terms of this License. 1.6 “Modifications” mean any addition to, deletion from, and/or change to, the substance and/or structure of the Original Code, any previous Modifications, the combination of Original Code and any previous Modifications, and/or any respective portions thereof. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code. 1.7 “Original Code” means (a) the Source Code of a program or other work as originally made available by Apple under this License, including the Source Code of any updates or upgrades to such programs or works made available by Apple under this License, and that has been expressly identified by Apple as such in the header file(s) of such work; and (b) the object code compiled from such Source Code and originally made available by Apple under this License. 1.8 “Source Code” means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code). 1.9 “You” or “Your” means an individual or a legal entity exercising rights under this License. For legal entities, “You” or “Your” includes any entity which controls, is controlled by, or is under common control with, You, where “control” means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity. 2. Permitted Uses; Conditions & Restrictions. Subject to the terms and conditions of this License, Apple hereby grants You, effective on the date You accept this License and download the Original Code, a world-wide, royalty-free, non-exclusive license, to the extent of Apple’s Applicable Patent Rights and copyrights covering the Original Code, to do the following: 2.1 Unmodified Code. You may use, reproduce, display, perform, internally distribute within Your organization, and Externally Deploy verbatim, unmodified copies of the Original Code, for commercial or non-commercial purposes, provided that in each instance: (a) You must retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Apple as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License; and (b) You must include a copy of this License with every copy of Source Code of Covered Code and documentation You distribute or Externally Deploy, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients’ rights hereunder, except as permitted under Section 6. 2.2 Modified Code. You may modify Covered Code and use, reproduce, display, perform, internally distribute within Your organization, and Externally Deploy Your Modifications and Covered Code, for commercial or non-commercial purposes, provided that in each instance You also meet all of these conditions: (a) You must satisfy all the conditions of Section 2.1 with respect to the Source Code of the Covered Code; (b) You must duplicate, to the extent it does not already exist, the notice in Exhibit A in each file of the Source Code of all Your Modifications, and cause the modified files to carry prominent notices stating that You changed the files and the date of any change; and (c) If You Externally Deploy Your Modifications, You must make Source Code of all Your Externally Deployed Modifications either available to those to whom You have Externally Deployed Your Modifications, or publicly available. Source Code of Your Externally Deployed Modifications must be released under the terms set forth in this License, including the license grants set forth in Section 3 below, for as long as you Externally Deploy the Covered Code or twelve (12) months from the date of initial External Deployment, whichever is longer. You should preferably distribute the Source Code of Your Externally Deployed Modifications electronically (e.g. download from a web site). 2.3 Distribution of Executable Versions. In addition, if You Externally Deploy Covered Code (Original Code and/or Modifications) in object code, executable form only, You must include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code. 2.4 Third Party Rights. You expressly acknowledge and agree that although Apple and each Contributor grants the licenses to their respective portions of the Covered Code set forth herein, no assurances are provided by Apple or any Contributor that the Covered Code does not infringe the patent or other intellectual property rights of any other entity. Apple and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to distribute the Covered Code, it is Your responsibility to acquire that license before distributing the Covered Code. 3. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License, You hereby grant to any person or entity receiving or distributing Covered Code under this License a non-exclusive, royalty-free, perpetual, irrevocable license, under Your Applicable Patent Rights and other intellectual property rights (other than patent) owned or controlled by You, to use, reproduce, display, perform, modify, sublicense, distribute and Externally Deploy Your Modifications of the same scope and extent as Apple’s licenses under Sections 2.1 and 2.2 above. 4. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof. 5. Limitations on Patent License. Except as expressly stated in Section 2, no other patent rights, express or implied, are granted by Apple herein. Modifications and/or Larger Works may require additional patent licenses from Apple which Apple may grant in its sole discretion. 6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the scope of the license granted herein (“Additional Terms”) to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Apple or any Contributor. You must obtain the recipient’s agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Apple and every Contributor harmless for any liability incurred by or claims asserted against Apple or such Contributor by reason of any such Additional Terms. 7. Versions of the License. Apple may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Apple. No one other than Apple has the right to modify the terms applicable to Covered Code created under this License. 8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part pre-release, untested, or not fully tested works. The Covered Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Covered Code, or any portion thereof, is at Your sole and entire risk. THE COVERED CODE IS PROVIDED “AS IS” AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND APPLE AND APPLE’S LICENSOR(S) (COLLECTIVELY REFERRED TO AS “APPLE” FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. APPLE AND EACH CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE, AN APPLE AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You acknowledge that the Covered Code is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Covered Code could lead to death, personal injury, or severe physical or environmental damage. 9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT SHALL APPLE OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF APPLE OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event shall Apple’s total liability to You for all damages (other than as may be required by applicable law) under this License exceed the amount of fifty dollars ($50.00). 10. Trademarks. This License does not grant any rights to use the trademarks or trade names “Apple”, “Apple Computer”, “Mac”, “Mac OS”, “QuickTime”, “QuickTime Streaming Server” or any other trademarks, service marks, logos or trade names belonging to Apple (collectively “Apple Marks”) or to any trademark, service mark, logo or trade name belonging to any Contributor. You agree not to use any Apple Marks in or as part of the name of products derived from the Original Code or to endorse or promote products derived from the Original Code other than as expressly permitted by and in strict compliance at all times with Apple’s third party trademark usage guidelines which are posted at http://www.apple.com/legal/guidelinesfor3rdparties.html. 11. Ownership. Subject to the licenses granted under this License, each Contributor retains all rights, title and interest in and to any Modifications made by such Contributor. Apple retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Apple (“Apple Modifications”), and such Apple Modifications will not be automatically subject to this License. Apple may, at its sole discretion, choose to license such Apple Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all. 12. Termination. 12.1 Termination. This License and the rights granted hereunder will terminate: (a) automatically without notice from Apple if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach; (b) immediately in the event of the circumstances described in Section 13.5(b); or (c) automatically without notice from Apple if You, at any time during the term of this License, commence an action for patent infringement against Apple; provided that Apple did not first commence an action for patent infringement against You in that instance. 12.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification, sublicensing and distribution of the Covered Code. All sublicenses to the Covered Code which have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of any party. 13. Miscellaneous. 13.1 Government End Users. The Covered Code is a “commercial item” as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data — Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein. 13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between or among You, Apple or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise. 13.3 Independent Development. Nothing in this License will impair Apple’s right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Larger Works, technology or products that You may develop, produce, market or distribute. 13.4 Waiver; Construction. Failure by Apple or any Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License. 13.5 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control. 13.6 Dispute Resolution. Any litigation or other dispute resolution between You and Apple relating to this License shall take place in the Northern District of California, and You and Apple hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. 13.7 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of California, except that body of California law concerning conflicts of law. Where You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exige que le present contrat et tous les documents connexes soient rediges en anglais. EXHIBIT A. “Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. This file contains Original Code and/or Modifications of Original Code as defined in and that are subject to the Apple Public Source License Version 2.0 (the ‘License’). You may not use this file except in compliance with the License. Please obtain a copy of the License at http://www.opensource.apple.com/apsl/ and read it before using this file. The Original Code and all software distributed under the License are distributed on an ‘AS IS’ basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the specific language governing rights and limitations under the License.” Donate to the OSI The OSI is the authority that defines Open Source, recognized globally by individuals, companies, and public institutions. The Open Source Initiative (OSI) is a 501(c)3 public benefit corporation, founded in 1998. --> Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:47
https://discuss.opensource.org/c/ai/5	Open Source AI - OSI Discuss OSI Discuss Open Source AI Topic Replies Views Activity Deep Dive: Artificial Intelligence 0 787 January 15, 2024 Open Source AI Impact: Japan’s Draft “Principle-Code” (Comments open until Jan 26 JST) news 2 24 January 12, 2026 Artificial Analysis Openness Index 0 13 January 8, 2026 Distillation and OSS Licensing 4 98 December 25, 2025 Open letter: Harnessing open source AI to advance digital sovereignty 0 67 November 20, 2025 IBM's Granite and contributions to LF AI & Data 1 184 October 3, 2025 Deep Dive: Data Governance brings world-class experts together 2 102 September 30, 2025 Report from OSS EU 2025 and AI_dev: What’s next for OSAID 0 84 September 10, 2025 Apertus: Swiss Open Source LLM 5 281 September 5, 2025 Presentation on Ai standards and OSAi - Portugal - Festa do Software Livre 2025 - Oct 3-5 0 69 September 1, 2025 Ai2 and fully Open AI models 0 122 August 14, 2025 OpenMDW License 1 218 July 14, 2025 Creative Commons launches CC Signals 3 132 July 5, 2025 Two big decisions in AI and training data this week 2 127 July 3, 2025 Open Source and the future of European AI sovereignty: Insights from Vivatech 2025 0 67 June 18, 2025 jBPM as an AI orchestration platform – Part 2 0 58 June 17, 2025 Feedback on OSAID barriers to adoption 0 83 May 19, 2025 User-triggered AI 0 97 May 9, 2025 DeepSeek-R1: does it conform to OSAID? 24 1119 April 15, 2025 Meta’s LLaMa license is still not Open Source 3 323 April 5, 2025 A diverse and decentralized ecosystem of AI models 0 92 April 3, 2025 Ensuring Open Source AI thrives under the EU's new AI rules 3 190 March 28, 2025 Mozilla.ai Blueprints 0 106 March 26, 2025 OLMo 2 32B: First fully open model to outperform GPT 3.5 and GPT 4o mini 4 336 March 24, 2025 An explanation of why there is no “degree of open” 3 264 March 11, 2025 Comparison of open source AI licenses 7 224 March 17, 2025 The Open Source AI Definition used in the wild 1 240 February 26, 2025 Should ‘Open Source AI’ Mean Exposing All Training Data? 1 109 February 21, 2025 Paper on "data scraping" by OECD news 0 94 February 17, 2025 Reimagining data for Open Source AI: A call to action 4 141 February 2, 2025 next page → Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://opensource.org/licenses#content	Licenses – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Home Licenses OSI Approved Licenses Open source licenses are licenses that comply with the Open Source Definition – in brief, they allow software to be freely used, modified, and shared. To be approved by the Open Source Initiative (also known as the OSI) a license must go through the Open Source Initiative’s license review process . Search Licenses You've searched for: ‘ ’ clear search Search for: Search Categories International Non-Reusable Other/Miscellaneous Popular / Strong Community Redundant with more popular Special Purpose Superseded Uncategorized Voluntarily retired clear categories View All Licenses Column headers with buttons are sortable License Name SPDX ID Category 1-clause BSD License BSD-1-Clause Other/Miscellaneous Academic Free License v. 3.0 AFL-3.0 Redundant with more popular Adaptive Public License 1.0 APL-1.0 Other/Miscellaneous Apache License, Version 2.0 Apache-2.0 Popular / Strong Community Apache Software License, version 1.1 Apache-1.1 Superseded Apple Public Source License 2.0 APSL-2.0 Non-Reusable Artistic License (Perl) 1.0 Artistic-1.0-Perl Superseded Artistic License 1.0 Artistic-1.0 Superseded Artistic License 2.0 Artistic-2.0 Other/Miscellaneous Attribution Assurance License AAL Redundant with more popular Blue Oak Model License BlueOak-1.0.0 Redundant with more popular Boost Software License 1.0 BSL-1.0 Uncategorized BSD+Patent BSD-2-Clause-Patent Special Purpose BSD-3-Clause-Open-MPI BSD-3-Clause-Open-MPI Other/Miscellaneous Cea Cnrs Inria Logiciel Libre License, version 2.1 CECILL-2.1 International CERN Open Hardware Licence Version 2 – Permissive CERN-OHL-P-2.0 Special Purpose CERN Open Hardware Licence Version 2 – Strongly Reciprocal CERN-OHL-S-2.0 Special Purpose CERN Open Hardware Licence Version 2 – Weakly Reciprocal CERN-OHL-W-2.0 Special Purpose CMU License MIT-CMU COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) CDDL-1.1 Uncategorized Common Development and Distribution License 1.0 CDDL-1.0 Popular / Strong Community Common Public Attribution License Version 1.0 CPAL-1.0 Uncategorized Common Public License Version 1.0 CPL-1.0 Superseded Computer Associates Trusted Open Source License 1.1 CATOSL-1.1 Non-Reusable Cryptographic Autonomy License CAL-1.0 Uncategorized CUA Office Public License CUA-OPL-1.0 Voluntarily retired Eclipse Public License -v 1.0 EPL-1.0 Superseded Eclipse Public License version 2.0 EPL-2.0 Popular / Strong Community eCos License version 2.0 eCos-2.0 Non-Reusable Educational Community License, Version 1.0 ECL-1.0 Superseded Educational Community License, Version 2.0 ECL-2.0 Special Purpose Eiffel Forum License, version 1 EFL-1.0 Superseded Eiffel Forum License, Version 2 EFL-2.0 Redundant with more popular Entessa Public License Version. 1.0 Entessa Non-Reusable EU DataGrid Software License EUDatagrid Non-Reusable European Union Public Licence, version 1.2 EUPL-1.2 International Fair License Fair Redundant with more popular Frameworx License 1.0 Frameworx-1.0 Non-Reusable GNU Affero General Public License version 3 AGPL-3.0-only Uncategorized GNU General Public License version 2 GPL-2.0 Popular / Strong Community GNU General Public License version 3 GPL-3.0-only Popular / Strong Community GNU General Public License, version 1 Superseded GNU Lesser General Public License version 2.1 LGPL-2.1 Popular / Strong Community GNU Lesser General Public License version 3 LGPL-3.0-only Popular / Strong Community GNU Library General Public License version 2 LGPL-2.0-only Popular / Strong Community Historical Permission Notice and Disclaimer HPND Redundant with more popular IBM Public License Version 1.0 IPL-1.0 Non-Reusable ICU License ICU Intel Open Source License Intel Voluntarily retired IPA Font License IPA Special Purpose ISC License ISC Uncategorized Jabber Open Source License Voluntarily retired JAM License Jam Other/Miscellaneous LaTeX Project Public License, Version 1.3c LPPL-1.3c Non-Reusable Lawrence Berkeley National Labs BSD Variant License BSD-3-Clause-LBNL Special Purpose Licence Libre du Québec – Permissive version 1.1 LiLiQ-P-1.1 International Licence Libre du Québec – Réciprocité forte version 1.1 LiLiQ-Rplus-1.1 International Licence Libre du Québec – Réciprocité version 1.1 LiLiQ-R-1.1 International Los Alamos National Labs BSD-3 Variant Non-Reusable Lucent Public License Version 1.02 LPL-1.02 Redundant with more popular Lucent Public License, Plan 9, version 1.0 LPL-1.0 Superseded Microsoft Public License MS-PL Uncategorized Microsoft Reciprocal License MS-RL Uncategorized MirOS Licence MirOS Uncategorized MIT No Attribution License MIT-0 Other/Miscellaneous MITRE Collaborative Virtual Workspace License Voluntarily retired Motosoto Open Source License Motosoto Non-Reusable Mozilla Public License 1.1 MPL-1.1 Superseded Mozilla Public License 2.0 MPL-2.0 Popular / Strong Community Mozilla Public License, version 1.0 MPL-1.0 Superseded Mulan Permissive Software License v2 MulanPSL-2.0 International Multics License Multics Non-Reusable NASA Open Source Agreement v1.3 NASA-1.3 Special Purpose NAUMEN Public License Naumen Non-Reusable Nokia Open Source License Version 1.0a NOKIA Non-Reusable Non-Profit Open Software License version 3.0 NPOSL-3.0 Uncategorized NTP License NTP Uncategorized Open Group Test Suite License OGTSL Uncategorized Open Logistics Foundation License v1.3 OLFL-1.3 Special Purpose Open Software License 2.1 OSL-2.1 Superseded Open Software License, version 1.0 OSL-1.0 Superseded OpenLDAP Public License Version 2.8 OLDAP-2.8 Redundant with more popular OSC License 1.0 International OSET Public License version 2.1 OSET-PL-2.1 Special Purpose PHP License 3.0 PHP-3.0 Superseded PHP License 3.01 PHP-3.01 Non-Reusable Python License, Version 2 PSF-2.0 Non-Reusable RealNetworks Public Source License Version 1.0 RPSL-1.0 Non-Reusable Reciprocal Public License 1.5 RPL-1.5 Uncategorized Reciprocal Public License, version 1.1 RPL-1.1 Superseded SIL OPEN FONT LICENSE OFL-1.1 Special Purpose Simple Public License SimPL-2.0 Uncategorized Sun Industry Standards Source License SISSL Voluntarily retired Sun Public License, Version 1.0 SPL-1.0 Non-Reusable The 2-Clause BSD License BSD-2-Clause Popular / Strong Community The 3-Clause BSD License BSD-3-Clause Popular / Strong Community The CNRI portion of the multi-part Python License CNRI-Python Non-Reusable The European Union Public License, version 1.1 EUPL-1.1 Superseded The MIT License MIT Popular / Strong Community The Nethack General Public License NGPL Non-Reusable The OCLC Research Public License 2.0 License Non-Reusable The Open Software License 3.0 OSL-3.0 Other/Miscellaneous The PostgreSQL License PostgreSQL Redundant with more popular The Q Public License Version QPL-1.0 Other/Miscellaneous The Ricoh Source Code Public License RSCPL Non-Reusable The Sleepycat License Sleepycat Non-Reusable The Sybase Open Source Licence Watcom-1.0 Non-Reusable The Universal Permissive License Version 1.0 UPL-1.0 Other/Miscellaneous The University of Illinois/NCSA Open Source License NCSA Redundant with more popular The Unlicense Unlicense Special Purpose The Vovida Software License v. 1.0 VSL-0.1 Non-Reusable The W3C® Software and Document license W3C-20150513 Non-Reusable The wxWindows Library Licence wxWindows Non-Reusable The X.Net, Inc. License Xnet Redundant with more popular The zlib/libpng License Zlib Other/Miscellaneous UNICODE LICENSE V3 Special Purpose Unicode, Inc. License Agreement – Data Files and Software Unicode-DFS-2015 Special Purpose Superseded Upstream Compatibility License v1.0 UCL-1.0 Special Purpose WordNet Non-Reusable Zero-Clause BSD 0BSD Other/Miscellaneous Zope Public License 2.0 ZPL-2.0 Superseded Zope Public License 2.1 ZPL-2.1 Redundant with more popular Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:47
https://discuss.opensource.org/t/ofa-symposium-2025-and-the-launch-of-the-open-technology-research-network-otrn/1330	OFA Symposium 2025 and the Launch of the Open Technology Research Network (OTRN) - General - OSI Discuss OSI Discuss OFA Symposium 2025 and the Launch of the Open Technology Research Network (OTRN) General system December 3, 2025, 8:47am 1 Originally published at: OFA Symposium 2025 and the Launch of the Open Technology Research Network (OTRN) – Open Source Initiative The OpenForum Academy Symposium 2025 organized by OpenForum Europe (OFE) brought together researchers, policymakers, practitioners, and open technology leaders for two days of deep inquiry into how open technologies shape our economies, infrastructures, and societies. 1 Like Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/u/shujisado	Profile - shujisado - OSI Discuss OSI Discuss shujisado Open Source guy. Chairman of Open Source Group Japan, LY Corporation’s OSPO Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://forem.com/t/jokes/page/6	jokes Page 6 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close jokes Follow Hide plz post the lols Create Post submission guidelines no spam don't be offensive (sexist, racist, homophobic, crude, etc.), the DEV code of conduct is still in place! make the jokes programming related-ish Older #jokes posts 3 4 5 6 7 8 9 10 11 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Edition 3 — Monday Memes Sukhpinder Singh Sukhpinder Singh Sukhpinder Singh Follow for Monday Memes Oct 7 '24 Edition 3 — Monday Memes # watercooler # jokes # programming # discuss 8 reactions Comments Add Comment 2 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 16 '24 Meme Monday # jokes # watercooler # discuss 43 reactions Comments 49 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 9 '24 Meme Monday # watercooler # discuss # jokes 23 reactions Comments 51 comments 1 min read Edition 1 - The Best Programming Memes to Brighten Your Day Sukhpinder Singh Sukhpinder Singh Sukhpinder Singh Follow for Monday Memes Sep 25 '24 Edition 1 - The Best Programming Memes to Brighten Your Day # watercooler # funny # laugh # jokes 5 reactions Comments Add Comment 2 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Sep 2 '24 Meme Monday # watercooler # discuss # jokes 23 reactions Comments 51 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 26 '24 Meme Monday # jokes # watercooler # discuss 35 reactions Comments 49 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 19 '24 Meme Monday # discuss # watercooler # jokes 57 reactions Comments 79 comments 1 min read I built a Free Badge Generator for Everyone Viorel PETCU Viorel PETCU Viorel PETCU Follow Aug 31 '24 I built a Free Badge Generator for Everyone # jokes # node # typescript # productivity 23 reactions Comments 1 comment 4 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 12 '24 Meme Monday # discuss # jokes # watercooler 63 reactions Comments 67 comments 1 min read I built a Free Badge Generator for Everyone Viorel PETCU Viorel PETCU Viorel PETCU Follow Aug 31 '24 I built a Free Badge Generator for Everyone # jokes # node # typescript # productivity 1 reaction Comments Add Comment 4 min read Which Linux command are you? ispmanager.com ispmanager.com ispmanager.com Follow for Ispmanager Aug 29 '24 Which Linux command are you? # jokes # linux # ubuntu # fun 18 reactions Comments 5 comments 2 min read When your code is as good at procrastinating as you are... 😅 Umair Iftikhar Umair Iftikhar Umair Iftikhar Follow Aug 27 '24 When your code is as good at procrastinating as you are... 😅 # jokes # elixir Comments Add Comment 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Aug 5 '24 Meme Monday # jokes # discuss # watercooler 43 reactions Comments 60 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 29 '24 Meme Monday # jokes # watercooler # discuss 49 reactions Comments 51 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 22 '24 Meme Monday # jokes # watercooler # discuss 30 reactions Comments 75 comments 1 min read Programming Memes Samuel Akong Samuel Akong Samuel Akong Follow Aug 6 '24 Programming Memes # jokes # watercooler # discuss 6 reactions Comments Add Comment 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 15 '24 Meme Monday # watercooler # discuss # jokes 59 reactions Comments 96 comments 1 min read What can Taylor Swift teach us about Software Engineering? Pawel Kadluczka Pawel Kadluczka Pawel Kadluczka Follow Aug 1 '24 What can Taylor Swift teach us about Software Engineering? # jokes # softwareengineering # devops # careerdevelopment 11 reactions Comments Add Comment 2 min read Code joke (may contain bugs) Ryan Snook Ryan Snook Ryan Snook Follow Jun 25 '24 Code joke (may contain bugs) # jokes Comments Add Comment 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 8 '24 Meme Monday # watercooler # discuss # jokes 48 reactions Comments 56 comments 1 min read T-shirt Tuesday! OpenSource OpenSource OpenSource Follow for Webcrumbs Jul 30 '24 T-shirt Tuesday! # jokes # watercooler # discuss # tshirt 20 reactions Comments 2 comments 1 min read Funny Friday and Self-care Pachi 🥑 Pachi 🥑 Pachi 🥑 Follow Jul 19 '24 Funny Friday and Self-care # jokes # watercooler # selfcare # discuss 15 reactions Comments 3 comments 2 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jul 1 '24 Meme Monday # watercooler # jokes # discuss 37 reactions Comments 54 comments 1 min read What is 'foo' 'bar' REALLY? OpenSource OpenSource OpenSource Follow for Webcrumbs Jul 15 '24 What is 'foo' 'bar' REALLY? # jokes # programming # beginners # development 19 reactions Comments 2 comments 1 min read Meme Monday Ben Halpern Ben Halpern Ben Halpern Follow Jun 24 '24 Meme Monday # discuss # watercooler # jokes 67 reactions Comments 88 comments 1 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:47
https://dev.to/itsugo/the-first-week-at-a-startup-taught-me-more-than-i-expected-158a#comment-33fbg	The First Week at a Startup Taught Me More Than I Expected - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Aryan Choudhary Posted on Jan 9           The First Week at a Startup Taught Me More Than I Expected # startup # beginners # career # learning Since many of you seemed interested in reading more about this, here’s my first-week reflection. My first week at a startup felt less like starting a job and more like stepping into motion that was already happening. There wasn’t a clean boundary around my role. Some days I was coding, some days debugging things I didn’t build, some days thinking through product decisions, other times helping wherever friction appeared. Titles mattered less than momentum. If something needed to move, someone had to move it. I knew this in theory. I wanted this kind of environment. What surprised me was how quickly wearing multiple hats stopped feeling like pressure and started feeling normal. I adapt fast by default. I don’t carry the constant fear that one mistake will end everything. Even when something goes wrong, it rarely means total collapse. In startups especially, people almost always find a way to adjust and recover. That belief makes the workload feel lighter than it looks on paper. At the same time, the instinct to look for better opportunities hasn’t disappeared. It didn’t switch off just because I signed an offer. It’s quieter now, but it’s still there. I don’t see that as disloyalty or restlessness, more like staying aware of my trajectory while committing to the present. What changed most after joining was the internal noise. For months, my mind was stuck in a constant loop of 24x7 applications, interviews, self-image, and preparation. Everything revolved around becoming employable. Now that loop has slowed down. I’m grounded in one place, working on a real set of problems with real constraints. That grounding created space to notice what I had neglected while job hunting. Japanese study had taken a back seat. Fitness became inconsistent. Writing slowed down. Even small creative habits (like voice acting ψ(._. )>) faded because everything was filtered through urgency. Being employed again made it possible to rebalance, but not without trade-offs. Time feels finite in a new way now. Some days that means less coding on personal projects. Some days it means choosing between hobbies. Sometimes it means accepting that momentum can’t be maximized in every direction at once. There are moments when I catch myself thinking I should "get a life", step back or relax more. But I also know this phase is temporary, and I’m grateful to have this many choices in front of me. This feels like a building phase, and I want to respect it without letting it turn into strain. This is just my perspective. People experience startups very differently. Some find them draining. Some thrive. Some leave quickly. I don’t think there’s a single correct way to do this. For me, the lesson from this first week isn’t about grinding harder or protecting myself aggressively. It’s about learning how to stay flexible without being scattered, committed without being trapped, and ambitious without being frantic. I’m still figuring it out. But for now, this feels like the right place to learn how. Top comments (16) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Collapse Expand   shambhavi525-sudo shambhavi525-sudo shambhavi525-sudo Follow Full-stack builder. Turning critical problems into lean, high-impact tech solutions. Email shalinibhavi525@gmail.com Joined Nov 3, 2025 • Jan 9 Dropdown menu Copy link Hide Love the point about titles mattering less than momentum. In a startup, the 'code' is only half the battle; the rest is just finding where the friction is and greasing the gears. It’s a specific kind of 'building phase' that changes how you think about problem-solving. Don't worry about 'getting a life' just yet—the 0 to 1 phase is where the best stories (and bugs) are made. Great read. Like comment: Like comment: 4  likes Like Comment button Reply Collapse Expand   Aryan Choudhary Aryan Choudhary Aryan Choudhary Follow Level up 10x faster Email aryanc1240@gmail.com Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 • Jan 9 Dropdown menu Copy link Hide Thank you for reading and supporting me through this comment! Really helps keep my spirits up! Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   Web Developer Hyper Web Developer Hyper Web Developer Hyper Follow "Having fun with IT technology" is my No.1 priority.🥳🎉 Let's enjoy and grow at the same time.🤝 #AI #ClaudeCode #Codex #Cursor #Cline #MCP #React #Nextjs #AWS #WebDev #FullStackDev Location Japan Joined Dec 27, 2024 • Jan 9 Dropdown menu Copy link Hide I’m glad to hear you’re doing well in the first week of your new job. I know you’re super clever and will get used to your new role in no time. Good luck!🫡 Like comment: Like comment: 3  likes Like Comment button Reply Collapse Expand   Aryan Choudhary Aryan Choudhary Aryan Choudhary Follow Level up 10x faster Email aryanc1240@gmail.com Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 • Jan 9 Dropdown menu Copy link Hide Yes thank you! I'll do my best! Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   SUNNY ANAND SUNNY ANAND SUNNY ANAND Follow Full Stack Systems Engineer building high-performance AI infrastructure. Architect of Nexus Gateway (Open Source AI Cache). Passionate about Go, Distributed Systems, and Scalability. Location India Work Founder @ Nexus Gateway Joined Jan 6, 2026 • Jan 11 Dropdown menu Copy link Hide This resonated a lot. Especially the shift from “being employable” to actually solving real problems — that grounding is underrated. Sounds like you’re navigating the chaos with awareness, which is probably the hardest skill to learn early on. Wishing you a solid learning curve ahead Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Aryan Choudhary Aryan Choudhary Aryan Choudhary Follow Level up 10x faster Email aryanc1240@gmail.com Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 • Jan 12 Dropdown menu Copy link Hide Thank you for reading and the well wishes @sunny_anand_dev !! Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Capin Judicael Akpado Capin Judicael Akpado Capin Judicael Akpado Follow 🎯 Web Developer \| ✍️ SEO Content Writer \| 🚀 Builder of High-Performance Digital Solutions Location Ouidah, Benin Pronouns He Work Freelance Web developer \|\| SEO Content Writer Joined Jun 20, 2025 • Jan 9 Dropdown menu Copy link Hide Thoughtful article ! Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Aryan Choudhary Aryan Choudhary Aryan Choudhary Follow Level up 10x faster Email aryanc1240@gmail.com Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 • Jan 9 Dropdown menu Copy link Hide Thank you for reading! Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Ankit Rattan Ankit Rattan Ankit Rattan Follow Coder By Profession, Creator By Mind! Email rattanankit2004@gmail.com Location Remote Education NIT Delhi Work JFL \| Ex-Microsoft \| Ex-CabEasy Joined Aug 21, 2024 • Jan 10 Dropdown menu Copy link Hide Yeah.. one learn more in the chaos of a startup week than in a quarter at a giant firm because you are defined by your impact, not just your title. Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Aryan Choudhary Aryan Choudhary Aryan Choudhary Follow Level up 10x faster Email aryanc1240@gmail.com Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 • Jan 10 Dropdown menu Copy link Hide Exactly, but the dilemma of which is better for me is still there... Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Ankit Rattan Ankit Rattan Ankit Rattan Follow Coder By Profession, Creator By Mind! Email rattanankit2004@gmail.com Location Remote Education NIT Delhi Work JFL \| Ex-Microsoft \| Ex-CabEasy Joined Aug 21, 2024 • Jan 10 Dropdown menu Copy link Hide Hmm, that’s common for all ig :) Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   jabo Landry jabo Landry jabo Landry Follow Pronouns Developer Prototype Joined Oct 10, 2025 • Jan 9 Dropdown menu Copy link Hide Wow, Congrats on your new experience Like comment: Like comment: 1  like Like Comment button Reply Collapse Expand   Aryan Choudhary Aryan Choudhary Aryan Choudhary Follow Level up 10x faster Email aryanc1240@gmail.com Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 • Jan 9 Dropdown menu Copy link Hide Thanks alot! Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   leob leob leob Follow Joined Aug 4, 2017 • Jan 9 Dropdown menu Copy link Hide Very thoughtful article, almost philosophical, good way to reflect on things! Like comment: Like comment: 2  likes Like Comment button Reply Collapse Expand   Aryan Choudhary Aryan Choudhary Aryan Choudhary Follow Level up 10x faster Email aryanc1240@gmail.com Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 • Jan 9 Dropdown menu Copy link Hide Thank you for reading! Like comment: Like comment: 2  likes Like Comment button Reply View full discussion (16 comments) Some comments may only be visible to logged-in visitors. Sign in to view all comments. Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse Aryan Choudhary Follow Level up 10x faster Location Pune, India Pronouns He/Him Work SDE 1 Joined Nov 5, 2024 More from Aryan Choudhary I Wanted to Work at a Startup. This Is What the First Glimpse Taught Me # career # startup # learning # beginners What Building Small, Personal Tools Taught Me This Year # productivity # sideprojects # devjournal # learning The 10 Levels of API Development (From Beginner to Production-Ready) # api # beginners # tutorial 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:47
https://discuss.opensource.org/u/moodler	Profile - moodler - OSI Discuss OSI Discuss moodler Since 2001 I’ve been best known as that Australian guy who founded and led Moodle, the open source learning platform that is used by institutions all over the world. A lot of my original code is still in Moodle today. I was full-time CEO of Moodle for over 20 years until January 2024. If you’re interested in Moodle should keep an eye on Moodle.org (for the software and community) and Moodle.com (for the business that pays for it all). I recently decided to move to a new role running the Moodle Research Lab as Head of Research, which is very exciting for me, because I get to get my hands dirty with cutting-edge technologies again (especially AI and AR), which is critical for understanding where education and open education technology will go in coming decades. I’m also the founder of Open EdTech, a non-profit based in Brussels, which is a new association of organisations and professionals interested in promoting open technology in education. I’m also a director of Open Education Global, a non-profit that promoted open education globally, as you might expect. You should be seeing an Open theme by now. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://forem.com/t/containers/page/14	Containers Page 14 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close # containers Follow Hide Security for container technologies like Docker and orchestration platforms like Kubernetes. Create Post Older #containers posts 11 12 13 14 15 16 17 18 19 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Deploy an App Across Accounts Hyelngtil Isaac Hyelngtil Isaac Hyelngtil Isaac Follow Sep 4 '25 Deploy an App Across Accounts # docker # aws # containerapps # containers Comments Add Comment 3 min read 🚀 Speed Up containerd Image Pulls with These Proven Techniques HexShift HexShift HexShift Follow Jul 31 '25 🚀 Speed Up containerd Image Pulls with These Proven Techniques # kubernetes # docker # containers # security Comments Add Comment 3 min read 🧱 containerd vs Docker: What's Really Happening Under the Hood? HexShift HexShift HexShift Follow Jul 31 '25 🧱 containerd vs Docker: What's Really Happening Under the Hood? # kubernetes # docker # containers # security Comments Add Comment 3 min read 🚀 How Kubernetes Is Modernizing the Tech Industry Muhammad Fahad Muhammad Fahad Muhammad Fahad Follow Jul 30 '25 🚀 How Kubernetes Is Modernizing the Tech Industry # modernstack # containers # kubernetes # cloudnative Comments Add Comment 2 min read 🚀 Containers vs Virtual Machines: What’s the Real Difference? Muhammad Fahad Muhammad Fahad Muhammad Fahad Follow Jul 30 '25 🚀 Containers vs Virtual Machines: What’s the Real Difference? # containers # virtualmachine # productivity Comments Add Comment 2 min read Understanding Docker: The Essential Guide for Developers Vikas Jyani Vikas Jyani Vikas Jyani Follow Sep 1 '25 Understanding Docker: The Essential Guide for Developers # docker # containers # devops # microservices Comments Add Comment 4 min read 🔧 How to Debug containerd Like a Pro HexShift HexShift HexShift Follow Jul 31 '25 🔧 How to Debug containerd Like a Pro # containers # docker # kubernetes # security 1 reaction Comments Add Comment 3 min read Modernizing Legacy Systems with AWS: Scalable, Secure & AI-Ready emmanuela Opurum emmanuela Opurum emmanuela Opurum Follow Jul 29 '25 Modernizing Legacy Systems with AWS: Scalable, Secure & AI-Ready # solutionsarchitect # awscloud # cloudnative # containers Comments Add Comment 1 min read You have to upgrade to SOCI V2 🤯 Piotr Pabis Piotr Pabis Piotr Pabis Follow for AWS Community Builders Sep 1 '25 You have to upgrade to SOCI V2 🤯 # ecs # aws # containers # docker Comments Add Comment 9 min read Run VMs alongside Containers in a Kubernetes Custer with KubeVirt Sayed Naweed Rizvi Sayed Naweed Rizvi Sayed Naweed Rizvi Follow Jul 29 '25 Run VMs alongside Containers in a Kubernetes Custer with KubeVirt # containers # kubernetes # kubevirt # virtualmachine Comments Add Comment 3 min read Mastering Kubernetes Autoscaling: The Key to Dynamic Cost Optimization Kubernetes with Naveen Kubernetes with Naveen Kubernetes with Naveen Follow Aug 21 '25 Mastering Kubernetes Autoscaling: The Key to Dynamic Cost Optimization # kubernetes # devops # containers # cloudnative Comments Add Comment 4 min read Building a Kubernetes Cluster on Raspberry Pi for Home Lab Learning Purushotam Adhikari Purushotam Adhikari Purushotam Adhikari Follow Sep 1 '25 Building a Kubernetes Cluster on Raspberry Pi for Home Lab Learning # javascript # raspberrypi # docker # containers Comments Add Comment 10 min read How To Connect AWS AppRunner Service To RDS And EC2 Dickson Victor Dickson Victor Dickson Victor Follow for AWS Community Builders Aug 28 '25 How To Connect AWS AppRunner Service To RDS And EC2 # apprunner # serverless # security # containers 1 reaction Comments Add Comment 3 min read Control storage access Alioke Emmanuel Nzubechukwu Alioke Emmanuel Nzubechukwu Alioke Emmanuel Nzubechukwu Follow Jul 25 '25 Control storage access # containers # googlecloud # cloudcomputing # webdev Comments Add Comment 4 min read The Docker Diet: How I Lost 1.1GB in 5 Steps SHUBHENDU SHUBHAM SHUBHENDU SHUBHAM SHUBHENDU SHUBHAM Follow Jul 24 '25 The Docker Diet: How I Lost 1.1GB in 5 Steps # docker # cloudnative # containers # dockercaptain Comments Add Comment 3 min read Running Your First Docker Container from GitHub in VS Code Habeeb Hameed Habeeb Hameed Habeeb Hameed Follow Jul 22 '25 Running Your First Docker Container from GitHub in VS Code # docker # vscode # containers # devops Comments Add Comment 2 min read Local MongoDB Replica Set Cluster for Real-Time Container Apps (with Mongo Express) Selim Selim Selim Follow Aug 9 '25 Local MongoDB Replica Set Cluster for Real-Time Container Apps (with Mongo Express) # mongodb # containers # podman # realtime 2 reactions Comments 1 comment 3 min read Day 30: Kubernetes Architecture Udoh Deborah Udoh Deborah Udoh Deborah Follow Aug 19 '25 Day 30: Kubernetes Architecture # linux # kubernetes # 90daysofdevops # containers 2 reactions Comments Add Comment 3 min read Install the Docker in OpenSUSE Jean Dias Jean Dias Jean Dias Follow Jul 17 '25 Install the Docker in OpenSUSE # docker # opensuse # linux # containers 1 reaction Comments Add Comment 1 min read 🐳 Understanding Containers and Docker: A Beginner's Guide SOVANNARO SOVANNARO SOVANNARO Follow Jul 16 '25 🐳 Understanding Containers and Docker: A Beginner's Guide # docker # containers # springboot Comments Add Comment 3 min read Understanding Kubernetes Architecture: A Beginner’s Guide AnkitDevCode AnkitDevCode AnkitDevCode Follow Aug 14 '25 Understanding Kubernetes Architecture: A Beginner’s Guide # kubernetes # containers # docker # k8 Comments Add Comment 5 min read Deploy an App with Docker Hyelngtil Isaac Hyelngtil Isaac Hyelngtil Isaac Follow Aug 12 '25 Deploy an App with Docker # aws # docker # container # containers Comments Add Comment 3 min read Docker Persistence: When and How to Keep Your Container Data Farouk BENNACEUR Farouk BENNACEUR Farouk BENNACEUR Follow Aug 9 '25 Docker Persistence: When and How to Keep Your Container Data # docker # dataengineering # ai # containers Comments Add Comment 2 min read การติดตั้ง Docker บน Windows แบบ Step by Step Watchara Sukka Watchara Sukka Watchara Sukka Follow Aug 9 '25 การติดตั้ง Docker บน Windows แบบ Step by Step # docker # containers # windows 2 reactions Comments Add Comment 2 min read Protecting an API with AWS API Gateway and Auth0 DarkEdges DarkEdges DarkEdges Follow Aug 15 '25 Protecting an API with AWS API Gateway and Auth0 # webdev # aws # containers Comments 1 comment 2 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:47
https://www.jetbrains.com/lp/mono/	JetBrains Mono: A free and open source typeface for developers \| JetBrains: Developer Tools for Professionals and Teams Intro Key features Design Font family How to install License Download font v 1.0.3 Updated 2,104 days ago Release notes Download font It’s free & open source Kotlin Java Go Python C++ C# 1 2 3 4 5 6 7 8 9 10 11 12 13 14 fun < T : Comparable< T >> List< T >. quickSort (): List< T > = when { size < 2 -> this else -> { val pivot = first () val (smaller , greater) = drop ( 1 ). partition { it <= pivot } smaller. quickSort () + pivot + greater. quickSort () } } fun main () { print ( listOf ( 5 , 0 , 1 , 5 , 3 , 7 , 4 , 2 ). quickSort ()) } Default editor font in JetBrains IDEs IntelliJ IDEA 1. Increased height for a better reading experience Explore letter construction 2. Adapted to reading code Explore 3. code-specific ligatures Explore ligatures 4. languages See full list 5. weights with matching italics Explore font family 6. JetBrains Mono is free & open source Read license See project on GitHub Increased letter height for better reading experience Characters remain standard in width, but the height of the lowercase is maximized. This approach keeps code lines to the length that developers expect, and it helps improve rendering since each letter occupies more pixels. Comparison Consider this in contrast to some other fonts. Consolas, for example, has slightly wider letters. However, they are still rather small, which forces you to increase the size by one point to make the font more readable. As a result, lines of code tend to run longer than expected. JetBrains Mono’s standard-width letters help keep lines to the expected length. Code-specific eye movement The shape of ovals approaches that of rectangular symbols. This makes the whole pattern of the text more clear-сut. The outer sides of ovals ensure there are no additional obstacles for your eyes as they scan the text vertically. Functional сonstruction JetBrains Mono’s typeface forms are simple and free from unnecessary details. Rendered in small sizes, the text looks crisper. The easier the forms, the faster the eye perceives them and the less effort the brain needs to process them. Distinctiveness of symbols “1”, “l”, and “I” are all easily distinguishable from each other. The zero has a dot inside. The letter “O” does not. The comma’s shape differs from that of the period, making them easier to tell apart at small sizes. The same holds true for derived symbols, as well. Cut strokes A radical cut at the end of strokes fits the pixel grid better and gives the typeface a stricter and more ‘tech’ personality. Italic The key to good italiсs is the fine-tuning of the contrast between upright and italic font. Typically, the angle is about 11°–12°. JetBrains Mono uses a 9° angle; this maintains the optimal contrast to minimize distraction and eye strain. Only for “a”, “y”, and “f” is the construction taken from True italic to slightly enhance the horizontal flow for the eyes. Ligatures for code A ligature is a character consisting of two or more joined symbols. Traditionally, it was introduced as a space-saving technique in printed texts. In code, this technique is adopted to show operators and is used mainly for two purposes: 1. To reduce noise by merging symbols and removing details so the eyes are processing less. Ligatures on Ligatures off 2. To balance whitespace more efficiently by shifting the glyphs in certain cases. Ligatures on Ligatures off JetBrains Mono font family thin Move mouse over the word to change Thin ExtraLight Light Regular Medium SemiBold Bold ExtraBold Italic Basic latin A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z Monospace ligatures -- --- == === != !== =!= =:= =/= <= >= && &&& &= ++ +++ *** ;; !! ?? ??? ?: ?. ?= <: :< :> >: <:< <> <<< >>> << >> \|\| -\| _\|_ \|- \|\|- \|= \|\|= ## ### #### #{ #[ ]# #( #? #_ #_( #: #! #= ^= <$> <$ $> <+> <+ +> <> < > </ </> /> <!-- <#-- --> -> ->> <<- <- <=< =<< <<= <== <=> <==> ==> => =>> >=> >>= >>- >- -< -<< >-> <-< <-\| <=\| \|=> \|-> <-> <~~ <~ <~> ~~ ~~> ~> ~- -~ ~@ [\|\|] \|] [\| \|} {\| [< >] \|> <\| \|\|> <\|\| \|\|\|> <\|\|\| <\|> ... .. .= ..< .? :: ::: := ::= :? :?> // /// / / /= //= /== @_ __ ??? <:< ;;; Diacritics Á Ă Ắ Ặ Ằ Ẳ Ẵ Ǎ Â Ấ Ậ Ầ Ẩ Ẫ Ä Ạ À Ả Ā Ą Å Ã Æ Ǽ Ć Č Ç Ĉ Ċ Ð Ď Đ É Ĕ Ě Ê Ế Ệ Ề Ể Ễ Ë Ė Ẹ È Ẻ Ē Ę Ɛ Ẽ Ǵ Ğ Ǧ Ĝ Ģ Ġ Ħ Ĥ Í Ĭ Î Ï İ Ị Ì Ỉ Ī Į Ĩ Ĵ Ķ Ĺ Ľ Ļ Ŀ Ł Ń Ň Ņ Ŋ Ñ Ó Ŏ Ô Ố Ộ Ồ Ổ Ỗ Ö Ọ Ò Ỏ Ơ Ớ Ợ Ờ Ở Ỡ Ő Ō Ǫ Ø Ǿ Õ Œ Þ Ŕ Ř Ŗ Ś Š Ş Ŝ Ș ẞ Ə Ŧ Ť Ţ Ț Ú Ŭ Û Ü Ụ Ù Ủ Ư Ứ Ự Ừ Ử Ữ Ű Ū Ų Ů Ũ Ẃ Ŵ Ẅ Ẁ Ý Ŷ Ÿ Ỵ Ỳ Ỷ Ȳ Ỹ Ź Ž Ż á ă â ä à ā ą å ã æ ǽ ć č ç ĉ ċ ð ď đ é ĕ ě ê ë ė è ē ę ə ğ ǧ ĝ ġ ħ ĥ i ı í ĭ î ï ì ī į ĩ j ȷ ĵ ĸ l ĺ ľ ŀ ł m n ń ŉ ň ŋ ñ ó ŏ ô ö ò ơ ő ō ø ǿ õ œ þ ŕ ř s ś š ş ŝ ß ſ ŧ ť ú ŭ û ü ù ư ű ū ģ ķ ļ ņ ŗ ţ ǫ ǵ ș ț ạ ả ấ ầ ẩ ẫ ậ ắ ằ ẳ ẵ ặ ẹ ẻ ẽ ế ề ể ễ ệ ỉ ị ọ ỏ ố ồ ổ ỗ ộ ớ ờ ở ỡ ợ ụ ủ ứ ừ ử ữ ự ỵ ỷ ỹ ų ů ũ ẃ ŵ ẅ ẁ ý ŷ ÿ ỳ z ź ž ż Numbers 0 0 1 2 3 4 5 6 7 8 9 ₀ ₁ ₂ ₃ ₄ ₅ ₆ ₇ ₈ ₉ ⁰ ¹ ² ³ ⁴ ⁵ ⁶ ⁷ ⁸ ⁹ ½ ¼ ¾ ↋ ↊ ૪ Punctuation . , : ; … ! ¡ ? ¿ · • ⁅ ⁆ # ․ ‾ / \ ‿ ( ) { } [ ] ❰ ❮ ❱ ❯ ⌈ ⌊ ⌉ ⌋ ⦇ ⦈ - – — ‐ _ ‚ „ “ ” ‘ ’ « » ‹ › ‴ " ' ⟨ ⟪ ⟦ ⟩ ⟫ ⟧ · ; Greek Α Β Γ Δ Ε Ζ Η Θ Ι Κ Λ Μ Ν Ξ Ο Π Ρ Σ Τ Υ Φ Χ Ψ Ω Ά Έ Ή Ί Ό Ύ Ώ Ϊ Ϋ Ϗ α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ ς σ τ υ φ χ ψ ω ί ϊ ΐ ύ ϋ ΰ ό ώ ά έ ή ϗ ϕ ϖ Cyrillic А Б В Г Ѓ Ґ Д Е Ё Ж З И Й К Ќ Л М Н О П Р С Т У Ў Ф Х Ч Ц Ш Щ Џ Ь Ъ Ы Љ Њ Ѕ Є Э І Ї Ј Ћ Ю Я Ђ Ғ Қ Ң Ү Ұ Ҷ Һ Ә Ө Ӝ Ӟ Ӥ Ӧ Ө Ӵ а б в г ѓ ґ д е ё ж з и й к ќ л м н о п р с т у ў ф х ч ц ш щ џ ь ъ ы љ њ ѕ є э і ї ј ћ ю я ђ ғ қ ң ү ұ ҷ һ ә ө ӝ ӟ ӥ ӧ ө ӵ Other symbols ₿ ¢ ¤ $ ₫ € ƒ ₴ ₽ £ ₮ ¥ ≃ ∵ ≬ ⋈ ∙ ≔ ∁ ≅ ∐ ⎪ ⋎ ⋄ ∣ ∕ ∤ ∸ ⋐ ⋱ ∈ ∊ ⋮ ∎ ⁼ ≡ ≍ ∹ ∃ ∇ ≳ ∾ ⥊ ⟜ ⎩ ⎨ ⎧ ⋉ ⎢ ⎣ ⎡ ≲ ⋯ ∓ ≫ ≪ ⊸ ⊎ ⨀ ⨅ ⨆ ⊼ ⋂ ⋃ ≇ ⊈ ⊉ ⊽ ⊴ ≉ ∌ ∉ ≭ ≯ ≱ ≢ ≮ ≰ ⋢ ⊄ ⊅ +− × ÷ = ≠ > < ≥ ≤ ± ≈ ¬ ~ ^ ∞ ∅ ∧ ∨ ∩ ∪ ∫ ∆ ∏ ∑ √ ∂ µ ∥ ⎜ ⎝ ⎛ ⎟ ⎠ ⎞ % ‰ ﹢ ⁺ ≺ ≼ ∷ ≟ ∶ ⊆ ⊇ ⤖ ⎭ ⎬ ⎫ ⋊ ⎥ ⎦ ⎤ ⊢ ≗ ∘ ∼ ⊓ ⊔ ⊡ ⊟ ⊞ ⊠ ⊏ ⊑ ⊐ ⊒ ⋆ ≣ ⊂ ≻ ∋ ⅀ ⊃ ⊤ ⊣ ∄ ∴ ≋ ∀ ⋰ ⊥ ⊻ ⊛ ⊝ ⊜ ⊘ ⊖ ⊗ ⊙ ⊕ ↑ ↗ → ↘ ↓ ↙ ← ↖ ↔ ↕ ↝ ↭↞ ↠ ↢ ↣ ↥ ↦ ↧ ⇥↩ ↪ ↾ ⇉ ⇑ ⇒ ⇓ ⇐ ⇔ ⇛ ⇧ ⇨ ⌄ ⌤ ➔ ➜ ➝ ➞ ⟵ ⟶ ⟷ ● ○ ◯ ◔ ◕ ◶ ◌ ◉ ◎ ◦ ◆ ◇ ◈ ◊ ■ □ ▪▫ ◧ ◨ ◩ ◪ ◫ ▲ ▶ ▼ ◀ △ ▷ ▽ ◁ ► ◄ ▻ ◅ ▴ ▸ ▾ ◂ ▵ ▹ ▿ ◃ ⌶ ⍺ ⍶ ⍀ ⍉ ⍥ ⌾ ⍟ ⌽ ⍜ ⍪ ⍢ ⍒ ⍋ ⍙ ⍫ ⍚ ⍱ ⍦ ⍎ ⍊ ⍖ ⍷ ⍩ ⍳ ⍸ ⍤ ⍛ ⍧ ⍅ ⍵ ⍹ ⎕ ⍂ ⌼ ⍠ ⍔ ⍍ ⌺ ⌹ ⍗ ⍌ ⌸ ⍄ ⌻ ⍇ ⍃ ⍯ ⍰ ⍈ ⍁ ⍐ ⍓ ⍞ ⍘ ⍴ ⍆ ⍮ ⌿ ⌷ ⍣ ⍭ ⍨ ⍲ ⍝ ⍡ ⍕ ⍑ ⍏ ⍬ ⚇ ⚠ ⚡ ✓ ✕ ✗ ✶ @ & ¶ § © ® ™ ° ′ ″ \| ¦ † ℓ ‡ № ℮ ␣ ⎋ ⌃ ⌞ ⌟ ⌝ ⌜ ⎊ ⎉ ⌂ ⇪ ⌫ ⌦ ⌨ ⌥ ⇟ ⇞ ⌘ ⏎ ⏻ ⏼ ⭘ ⏽ ⏾ ⌅ � ˳ ˷ 𝔸 𝔹 ℂ 𝔻 𝔼 𝔽 𝔾 ℍ 𝕀 𝕁 𝕂 𝕃 𝕄 ℕ 𝕆 ℙ ℚ ℝ 𝕊 𝕋 𝕌 𝕍 𝕎 𝕏 𝕐 ℤ 𝕒 𝕓 𝕔 𝕕 𝕖 𝕗 𝕘 𝕙 𝕚 𝕛 𝕜 𝕝 𝕞 𝕟 𝕠 𝕡 𝕢 𝕣 𝕤 𝕥 𝕦 𝕧 𝕨 𝕩 𝕪 Block symbols ▁ ▂ ▃ ▄ ▅ ▆ ▇ █ ▀ ▔ ▏ ▎ ▍ ▌ ▋ ▊ ▉ ▐ ▕ ▖ ▗ ▘ ▙ ▚ ▛ ▜ ▝ ▞ ▟ ░ ▒ ▓ Box drawing ┌ └ ┐ ┘ ┼ ┬ ┴ ├ ┤ ─ │ ╡ ╢ ╖ ╕ ╣ ║ ╗ ╝ ╜ ╛ ╞ ╟ ╚ ╔ ╩ ╦ ╠ ═ ╬ ╧ ╨ ╤ ╥ ╙ ╘ ╒ ╓ ╫ ╪ ━ ┃ ┄ ┅ ┆ ┇ ┈ ┉ ┊ ┋ ┍ ┎ ┏ ┑ ┒ ┓ ┕ ┖ ┗ ┙ ┚ ┛ ┝ ┞ ┟ ┠ ┡ ┢ ┣ ┥ ┦ ┧ ┨ ┩ ┪ ┫ ┭ ┮ ┯ ┰ ┱ ┲ ┳ ┵ ┶ ┷ ┸ ┹ ┺ ┻ ┽ ┾ ┿ ╀ ╁ ╂ ╃ ╄ ╅ ╆ ╇ ╈ ╉ ╊ ╋ ╌ ╍ ╎ ╏ ╭ ╮ ╯ ╰ ╱ ╲ ╳ ╴ ╵ ╶ ╷ ╸ ╹ ╺ ╻ ╼ ╽ ╾ ╿ Control codes ␆ ␈ ␇ ␘ ␍ ␐ ␡ ␔ ␑ ␓ ␒ ␙ ␃ ␄ ␗ ␅ ␛ ␜ ␌ ␝ ␉ ␊ ␕ ␤ ␀ ␞ ␏ ␎ ␠ ␁ ␂ ␚ ␖ ␟ ␋ Powerline        148 languages supported Afrikaans Albanian Asu Basque Belarusian Bemba Bena Bosnian Bulgarian Catalan Cebuano Chiga Cornish Corsican Croatian Czech Danish Dutch Embu English Erzya Esperanto Estonian Faroese Filipino Finnish French Friulian Galician Ganda German Greek Gusii Hungarian Icelandic Ido Inari Sami Indonesian Ingrian (Izhorian) Interlingua Irish Italian Javanese (Latin) Jju Jola-Fonyi Jèrriais Kabuverdianu Kala Lagaw Ya Kalaallisut (Latin) Kalenjin Kamba Kapampangan (Latin) Kaqchikel Karakalpak (Latin) Karelian (Latin) Kashubian Kazakh Cyrillic Kikongo Kikuyu Kinyarwanda Kiribati Kirundi Kurdish (Latin) Ladin Latvian Lithuanian Lojban Lombard Low German Luo Luxembourgish Luyia Maasai Macedonian Machame Makhuwa Makhuwa-Meetto Makonde Malagasy Malay Maltese Manx Meru Mongolian Morisyen Māori North Ndebele Northern Sami Northern Sotho Norwegian Bokmål Norwegian Nynorsk Nyanja Nyankole Occitan Oromo Oshiwambo Ossetian (Latin) Papiamento Piedmontese Polish Portuguese Quechua Q’eqchi’ Rarotongan Romanian Romansh Rombo Rotokas Rundi Russian Rwa Samburu Sango Sangu Sardinian Scottish Gaelic Sena Serbian Shambala Shona Slovak Slovenian Soga Somali Sorbian (Lower Sorbian) Sorbian (Upper Sorbian) South Ndebele Southern Sotho Spanish Swahili Swati Swedish Swiss German Taita Taroko Teso Tsonga Tswana Turkish Turkmen Udmurt Ukrainian Vunjo Walloon Walser Wolof Xhosa Zulu How to install In JetBrains IDEs The most recent version of JetBrains Mono ships with your JetBrains IDE starting with v2019.3. Select JetBrains Mono in the IDE settings: go to Preferences/Settings → Editor → Font, and then select JetBrains Mono from the Font dropdown. Another IDE or an older version of a JetBrains IDE Download font Unzip the archive and install the font: Select all font files in the folder and double-click the “Install Font” button. Select all font files in the folder, right-click any of them, then pick “Install” from the menu. Unpack fonts to ~/.local/share/fonts (or /usr/share/fonts, to install fonts system-wide) and fc-cache -f -v Restart your IDE. Go to Preferences/Settings → Editor → Font, and pick JetBrains Mono from the Font dropdown. Recommended settings for the font Size: 13 Line spacing: 1.2 License JetBrains Mono typeface is available under the SIL Open Font License 1.1 license and can be used free of charge, for both commercial and non-commercial purposes. You do not need to give credit to JetBrains, although we will appreciate it very much if you do. FAQ May I install JetBrains Mono on my system and use it in any code editor? -> Yes . May I make and print a poster with JetBrains Mono? -> Yes . May I use JetBrains Mono in my logotype? -> Yes . May I use JetBrains Mono on my website? -> Yes . May I use JetBrains Mono in my applications? -> Yes . May I design my own font based on JetBrains Mono? -> Yes . In this case, you need to indicate that it is based on JetBrains Mono. Credits Type designer Philipp Nurullin Project lead Konstantin Bulenkov Thanks to Nikita Prokopov Eugene Auduchinok Dmitrij Batrak Tatiana Tulupenko IntelliJ UX Team + the whole JetBrains Team Share your feedback on GitHub English Privacy & Security Terms of Use Trademarks Legal Genuine Tools Copyright © 2000- 2025 JetBrains s.r.o. Developed with drive and IntelliJ IDEA	2026-01-13T08:49:47
https://discuss.opensource.org/t/proposal-to-clarify-the-spirit-and-purpose-of-the-open-source-definition/1287	Proposal to Clarify the Spirit and Purpose of the Open Source Definition - General - OSI Discuss OSI Discuss Proposal to Clarify the Spirit and Purpose of the Open Source Definition General shu September 3, 2025, 8:45am 1 I’ve been an OSS contributor and maintainer for 10 years. During that time, I’ve repeatedly explained the necessity and value of continuing to contribute to OSS, even though it incurs costs as a member of a company. However, these explanations have not really taken hold. This is because the free-rider mentality is still deeply rooted. So, three years ago, on September 3, 2022, I noticed and sent a message about the challenges that in-house contributors face in for-profit organizations. It was where the Open Source Definition (OSD) is sometimes understood only as a license compliance checklist. This narrow interpretation often fosters a free-rider mentality, where companies think “as long as we follow the OSD and licenses, we owe nothing more.” Since then, I have continued observing and discussing this issue, and I see that the situation has only become more important: The global adoption of OSS has deepened, but in many organizations, contribution is still undervalued compared to usage. Security incidents (e.g., supply chain vulnerabilities) have revealed the risks of a pure free-rider approach. The OSPO movement (led by LF, TODO Group, and OSPO++) has made progress, but in organizations where the OSD is seen as the ultimate reference, contributions are not recognized as essential. Even with the implementation of the CRA, there are still companies in countries that believe it does not apply to them because they are not in the EU. I believe this gap comes from the fact that the OSD, while powerful and trusted, does not explicitly and firstly describe why it was created—namely, to promote open collaboration and innovation. This purpose can be found in your own history page, where “open source” was coined not only to increase adoption, but also to advocate for the superiority of open development, and to encourage engaged communities. However, this will dramatically reduce the number of people who dig deeper beyond the OSD page. Therefore, I would like to kindly propose: Add an introductory statement to the OSD (or its official explanation) clarifying its original spirit and purpose—promoting open collaboration, community participation, and innovation. Provide multilingual summaries of this purpose, so that non-English-native communities can understand OSS not just as “free to use,” but as “valuable to co-create.” I sincerely believe this clarification will: Help reduce the free-rider mentality in corporations. Support OSPOs and advocates worldwide. Empower contributors who struggle to explain the value of their work inside organizations. In 2022, I closed my message with the wish: “Could you describe the purpose for which the OSD was created?” Now, three years later, I renew this request as a concrete proposal to strengthen the global understanding of open source. @stefano This topic was submitted previously, and I’d like to start a discussion now. Thanks! 2 Likes shujisado September 4, 2025, 1:40pm 2 I understand your desire to add educational supplements to the Open Source Definition (OSD) for purposes such as promoting contribution. However, I believe that doing so risks turning the OSD—which has guaranteed a minimal and neutral standard of freedom—into a vehicle for overlaying it with “spirit” or ideology. The OSD is, and should remain, a minimal and neutral standard for assessing license compliance; its function is a testable rule set. If we mix personal values or codes of conduct into it, the objectivity of that standard will be undermined. For example, suppose a preamble aimed at encouraging contribution were added to the OSD. That would open the door to claims such as “merely free-riding on the results of Open Source development is contrary to the spirit of the OSD,” importing spirit-based interpretations into judgments about what is or isn’t open source. Many may feel that is a good thing, but since 1998 I have consistently argued that open source may be free-ridden upon and even used for bad purposes. That may look old-fashioned to you, but it is one of the reasons our community grew. I understand the world you want, but it is something that must never be incorporated into the OSD. If the OSI were to prepare some separate auxiliary document, including it there could be acceptable; nevertheless, any attempt to place it into the OSD itself would likely meet with substantial opposition. Moreover, encouraging contribution is the domain of OSPOs. As I see it, spreading what you advocate is the role of the TODO Group, the consortium of OSPOs. Work through the TODO Group and the Linux Foundation would likely be more effective for your objectives. 1 Like nick September 4, 2025, 4:26pm 3 This is an interesting discussion and I agree with many points raised here. The OSAID does have a preamble which to some extent explicitly outlines open collaboration, community participation, and innovation as goals: Open Source has demonstrated that massive benefits accrue to everyone after removing the barriers to learning, using, sharing and improving software systems. These benefits are the result of using licenses that adhere to the Open Source Definition. For AI, society needs at least the same essential freedoms of Open Source to enable AI developers, deployers and end users to enjoy those same benefits: autonomy, transparency, frictionless reuse and collaborative improvement. At the same time, as highlighted by @shujisado -san, the OSD has guaranteed a minimal and neutral standard of freedom. There have been several attempts to incorporate ethical restrictions and collaborative obligations to “Open Source” along these past 25+ years. The OSI has not shied away from engaging in these conversations, and in fact we have even published a research about Delayed Open Source Publication and BUSL (Business Source License) in 2024 to highlight how some companies have followed this strategy to restrict freedoms temporarily as a way to inhibit “free riders” and make their projects more “sustainable.” The fact that Open Source sets a minimal and neutral standard does not mean that each individual project or company making use of these projects cannot build on top of this and establish higher standards. Many projects like Python or Kubernetes set higher standards on top of the OSD, such as embracing an open governance model and promoting community diversity and inclusiveness. Also, many companies and even governments have published their own “Open Source Manifesto.” OSPOs play a fundamental role there. Finally, I would like to recommend this blog post which delves into these questions. shu September 5, 2025, 7:33am 4 @shujisado @nick Thank you for your comments! After 25 years, technology has advanced dramatically, and with the emergence of source code sharing systems such as GitHub, I recognize that there has been an evolution from the original method of “each one creating their own derivative” to the method of “everyone building one thing together,” and that this method has become widely spread. At the same time, I believe that the meaning and value of the term “open source” have also come to be recognized in an advanced form. When people ask, “What is open source?”, the very first thing, or at least something they always refer to, is the OSD. I also believe that it still holds unchanged value even after 25 years. However, there are many people who, when looking at the OSD and the list of corresponding licenses, recognize that there is nothing more, and do not try to understand more deeply. There are probably many people who do not even look at the annotated OSD. As Sado-san says, the enlightenment of further values, governance, and best practices may be the mission of TODO or the OSPO Alliance (though OSPO++ seems to have disappeared), and not the mission of the OSD. In understanding open source, the OSD, which defined the term, is an indispensable historical preface, and its simplicity is also a wonderful thing. However, it can also be said that the OSD has not caught up with new values and methods. I think the term “Open Source” no longer refers solely to “the distribution terms” as stated in the OSD Introduction. So, I hope that you will show by yourselves that there is now also “And more…” beyond that. The annotated OSD also continues to hold great value, but it cannot be called new, so it might be good enough if it takes the form of recommending reference to TODO or the OSPO Alliance. Alternatively, it may be a good idea to change the Open Source Definition to a title with more appropriate scope, such as Open Source Terms of Distribution. I do not wish to exclude free riders, nor do I wish to make contributions obligatory. The freedom to use and to modify freely is the very origin, but it must be strongly asserted that we must not forget that people gather there, that maintainers, contributors, and supporters form and sustain communities. It is precisely the OSD, which defined the term “open source,” that I strongly wish would declare that it does not end with only the OSD and the list of corresponding licenses. I would be grateful if you could recognize that by not doing so, people with only shallow understanding up to the OSD or the license list may obstruct those who wish to move further forward. 1 Like shu January 7, 2026, 5:52am 5 @debbryant What do you think about updating OSD? shujisado January 7, 2026, 2:02pm 6 The OSD has served for more than 25 years as a criterion for evaluating distribution terms that guarantee freedom. Its strength lies in the fact that it is not a value judgment, but a framework that enables relatively objective determinations of compliance or non-compliance. I agree with the point that healthy communities sustain Open Source, and I also think it is wonderful to emphasize its importance. However, if such a message is incorporated as a declaration within the OSD itself, the role of the OSD would expand from a criterion for judging distribution terms into a declaration of desirable conduct or ethics, and its interpretation would become unstable. More concretely, even if the proposal is made in good faith, it creates room for third parties to weaponize the wording by claiming that something is “not Open Source because it is detrimental to the community.” Once that happens, Open Source risks shifting from a license classification into a classification based on community values. I consider this a serious risk to the breadth and diversity of Open Source. If there ever comes a time when the term Open Source is no longer taken seriously, I have argued over the past quarter century that this kind of semantic drift would be exactly how it happens. For that reason, while the importance of community and sustainability should be asserted strongly, it should be positioned as a separate document or initiative, not as part of the OSD. I understand that in recent years OSI has been working with various external institutions to guide the community in a better direction. That role is already sufficient. Rather than expanding the OSD, OSI should pursue that goal through guidelines, educational materials, and best practices. To me, this also looks like an area that organizations such as the TODO Group are better positioned to lead. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/u/jberkus	Profile - jberkus - OSI Discuss OSI Discuss jberkus Josh Berkus is a long-time open source contributor and current member of the OSI Board. He works for Red Hat. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://twitter.com/intent/tweet?text=%22Identify%20AWS%20Network%20Services%22%20by%20%40NtombizakhonaX%20%23DEVCommunity%20https%3A%2F%2Fdev.to%2Faws-builders%2Fidentify-aws-network-services-3pba	JavaScript is not available. We’ve detected that JavaScript is disabled in this browser. Please enable JavaScript or switch to a supported browser to continue using x.com. You can see a list of supported browsers in our Help Center. Help Center Terms of Service Privacy Policy Cookie Policy Imprint Ads info © 2026 X Corp. Something went wrong, but don’t fret — let’s give it another shot. Try again Some privacy related extensions may cause issues on x.com. Please disable them and try again.	2026-01-13T08:49:47
https://forem.com/t/containers/page/6	Containers Page 6 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close # containers Follow Hide Security for container technologies like Docker and orchestration platforms like Kubernetes. Create Post Older #containers posts 3 4 5 6 7 8 9 10 11 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Getting Started with Kubernetes: A Complete Guide InstaDevOps InstaDevOps InstaDevOps Follow Nov 6 '25 Getting Started with Kubernetes: A Complete Guide # kubernetes # k8s # containers # devops Comments Add Comment 5 min read Pod - Deployment - Service Shiva Charan Shiva Charan Shiva Charan Follow Nov 27 '25 Pod - Deployment - Service # containers # kubernetes # devops # beginners 1 reaction Comments Add Comment 2 min read Kubernetes: Introduction to Container Orchestration Naveen Jayachandran Naveen Jayachandran Naveen Jayachandran Follow Nov 3 '25 Kubernetes: Introduction to Container Orchestration # kubernetes # containers # azure # aws Comments Add Comment 3 min read Master Pro Docker Techniques: A Best Practices Guide for Lean, Secure Containers Smooth Code Smooth Code Smooth Code Follow Nov 4 '25 Master Pro Docker Techniques: A Best Practices Guide for Lean, Secure Containers # docker # devops # containers # softwareengineering 1 reaction Comments Add Comment 4 min read Kubernetes - Images Naveen Jayachandran Naveen Jayachandran Naveen Jayachandran Follow Nov 3 '25 Kubernetes - Images # kubernetes # devops # containers # aws Comments Add Comment 2 min read What Exactly is Docker and Why its necessary P. Acharya P. Acharya P. Acharya Follow Dec 6 '25 What Exactly is Docker and Why its necessary # webdev # docker # containers # devops 1 reaction Comments Add Comment 6 min read DevPill 2: How to build and push a docker image to google cloud Artifact Registry Raul Paes Silva Raul Paes Silva Raul Paes Silva Follow Dec 6 '25 DevPill 2: How to build and push a docker image to google cloud Artifact Registry # gcp # docker # containers Comments Add Comment 1 min read END-TO-END Deployment Of Django App on AWS EKS Cluster On-cloud7 On-cloud7 On-cloud7 Follow Dec 6 '25 END-TO-END Deployment Of Django App on AWS EKS Cluster # eks # aws # containers # cloudcomputing 6 reactions Comments Add Comment 2 min read Writing a tiny PID 1 for containers in pure assembly (x86-64 + ARM64) Bogdan Bogdan Bogdan Follow Dec 6 '25 Writing a tiny PID 1 for containers in pure assembly (x86-64 + ARM64) # opensource # linux # assembly # containers Comments Add Comment 7 min read Working with Docker Images: From Basics to Best Practices Haripriya Veluchamy Haripriya Veluchamy Haripriya Veluchamy Follow Dec 5 '25 Working with Docker Images: From Basics to Best Practices # docker # containers # cloud # devops 2 reactions Comments Add Comment 5 min read From Manual Deployment to Docker Compose Muhammad Usman Muhammad Usman Muhammad Usman Follow Nov 1 '25 From Manual Deployment to Docker Compose # docker # containers # devops Comments Add Comment 2 min read std::vector: From Basics to Implementation Intricacies Oleg Goncharov Oleg Goncharov Oleg Goncharov Follow Nov 5 '25 std::vector: From Basics to Implementation Intricacies # cpp # containers # memory # bestpractices Comments Add Comment 20 min read Docker Basics: Getting Started with Containers chandra penugonda chandra penugonda chandra penugonda Follow Dec 6 '25 Docker Basics: Getting Started with Containers # docker # containers Comments Add Comment 1 min read Exclusive Reveal: Code Sandbox Tech Behind Manus and Claude Agent Skills Peng Qian Peng Qian Peng Qian Follow Nov 23 '25 Exclusive Reveal: Code Sandbox Tech Behind Manus and Claude Agent Skills # ai # programming # containers # agentaichallenge Comments Add Comment 12 min read Mastering Docker Logs: A Comprehensive Tutorial Ayooluwa Isaiah Ayooluwa Isaiah Ayooluwa Isaiah Follow for Dash0 Nov 14 '25 Mastering Docker Logs: A Comprehensive Tutorial # docker # containers # kubernetes # devops Comments Add Comment 13 min read How to Create An Amazon EKS - Step by Step for Beginners On-cloud7 On-cloud7 On-cloud7 Follow Nov 30 '25 How to Create An Amazon EKS - Step by Step for Beginners # aws # eks # containers # cloud 6 reactions Comments Add Comment 2 min read Simplifying Container Ops: What ECS Express Mode Brings to the Table Tanushree Aggarwal Tanushree Aggarwal Tanushree Aggarwal Follow for AWS Community Builders Nov 30 '25 Simplifying Container Ops: What ECS Express Mode Brings to the Table # aws # cloud # containers # ecs 9 reactions Comments Add Comment 7 min read Understanding Docker Networking: A Practical, Small-Scale Production Emulation Faizan Firdousi Faizan Firdousi Faizan Firdousi Follow Nov 29 '25 Understanding Docker Networking: A Practical, Small-Scale Production Emulation # devops # docker # containers # linux 1 reaction Comments Add Comment 2 min read Why Docker Is Not Truly Native on Windows and macOS Faizan Firdousi Faizan Firdousi Faizan Firdousi Follow Nov 29 '25 Why Docker Is Not Truly Native on Windows and macOS # devops # linux # containers # docker 1 reaction Comments Add Comment 1 min read Docker storage drivers Megha Sharma Megha Sharma Megha Sharma Follow Nov 17 '25 Docker storage drivers # devops # cloud # containers # docker Comments 2 comments 5 min read Kubernetes : Your Ultimate Cheatsheet kaustubh yerkade kaustubh yerkade kaustubh yerkade Follow Nov 28 '25 Kubernetes : Your Ultimate Cheatsheet # kubernetes # containers # docker # kubectl 1 reaction Comments 1 comment 7 min read FULL GUIDE TO KUBERNETES YAML Harsh Mishra Harsh Mishra Harsh Mishra Follow Nov 28 '25 FULL GUIDE TO KUBERNETES YAML # kubernetes # containers Comments Add Comment 23 min read AWS ECS Managed Instances: The Middle Ground We've Been Waiting For Omar Fathy Omar Fathy Omar Fathy Follow Nov 27 '25 AWS ECS Managed Instances: The Middle Ground We've Been Waiting For # aws # containers # devops 2 reactions Comments 1 comment 6 min read My Journey With Docker Commands — Simple Tips Sudha Velan Sudha Velan Sudha Velan Follow Nov 26 '25 My Journey With Docker Commands — Simple Tips # docker # containers # beginners 1 reaction Comments Add Comment 1 min read From image to HTTPS endpoint in one step with ECS Express Mode Venkata Pavan Vishnu Rachapudi Venkata Pavan Vishnu Rachapudi Venkata Pavan Vishnu Rachapudi Follow for AWS Community Builders Nov 22 '25 From image to HTTPS endpoint in one step with ECS Express Mode # aws # docker # containers # ecs 10 reactions Comments Add Comment 3 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:47
https://discuss.opensource.org/t/welcome-to-the-osi-community/5	Welcome to the OSI community! 👋 - General - OSI Discuss OSI Discuss Welcome to the OSI community! 👋 General system January 11, 2024, 9:11pm 1 We are so glad you joined us. Here are some things you can do to get started: Introduce yourself by adding your picture and information about yourself and your interests to your profile . What is one thing you’d like to be asked about? Get to know the community by browsing discussions that are already happening here. When you find a post interesting, informative, or entertaining, use the to show your appreciation or support! Contribute by commenting, sharing your own perspective, asking questions, or offering feedback in the discussion. Before replying or starting new topics, please review the Community Guidelines . If you need help or have a suggestion, feel free to ask in Site Feedback or contact the admins . 6 Likes Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/t/is-it-possible-to-create-a-license-based-on-0bsd-extra-development-duties/1323	Is it possible to create a license based on 0BSD + extra development duties? - General - OSI Discuss OSI Discuss Is it possible to create a license based on 0BSD + extra development duties? General standards , regulation , clearlydefined , question Akhil_Chandran November 16, 2025, 4:00pm 1 Hello everyone, I have a question about license structure and compatibility with the Open Source Definition (OSD). I am exploring the idea of creating a new open-source license that uses 0BSD as the legal base and adds extra development duties (for example, documentation, testing, traceability, or similar project-structure requirements). These duties would apply only to contributors and maintainers, not to end users, and they would not restrict how the software can be used, modified, or redistributed. My question is: Is it possible for a license built on 0BSD + additional development duties to remain compatible with the Open Source Definition? I am not asking for approval at this stage, only for general guidance on whether this type of structure is acceptable within OSI’s understanding of open-source licensing. Thank you for your time and any comments you can provide. Akhil Chandran Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://twitter.com/intent/tweet?text=%22LocalStorage%20vs%20Cookies%3A%20All%20You%20Need%20To%20Know%20About%20Storing%20JWT%20Tokens%20Securely%20in%20The%20Front-End%22%20by%20%40michwirantono%20%23DEVCommunity%20https%3A%2F%2Fdev.to%2Fcotter%2Flocalstorage-vs-cookies-all-you-need-to-know-about-storing-jwt-tokens-securely-in-the-front-end-15id	JavaScript is not available. We’ve detected that JavaScript is disabled in this browser. Please enable JavaScript or switch to a supported browser to continue using x.com. You can see a list of supported browsers in our Help Center. Help Center Terms of Service Privacy Policy Cookie Policy Imprint Ads info © 2026 X Corp. Something went wrong, but don’t fret — let’s give it another shot. Try again Some privacy related extensions may cause issues on x.com. Please disable them and try again.	2026-01-13T08:49:47
https://discuss.opensource.org/t/dpga-s-annual-members-meeting-advancing-open-source-dpgs-for-the-public-good/1332	DPGA’s Annual Members Meeting: Advancing Open Source & DPGs for the Public Good - General - OSI Discuss OSI Discuss DPGA’s Annual Members Meeting: Advancing Open Source & DPGs for the Public Good General system December 6, 2025, 9:32am 1 Originally published at: DPGA’s Annual Members Meeting: Advancing Open Source & DPGs for the Public Good – Open Source Initiative The DPGA’s Annual Members Meeting highlighted several priorities that resonate strongly with OSI’s mission, including promoting Open Source software, advancing public-interest AI, and strengthening global collaboration. 1 Like Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://forem.com/t/containers/page/10	Containers Page 10 - Forem Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close # containers Follow Hide Security for container technologies like Docker and orchestration platforms like Kubernetes. Create Post Older #containers posts 7 8 9 10 11 12 13 14 15 Posts Left menu 👋 Sign in for the ability to sort posts by relevant , latest , or top . Right menu Rehosting Bitnami Secure Images with Specific Tags vaggeliskls vaggeliskls vaggeliskls Follow Sep 15 '25 Rehosting Bitnami Secure Images with Specific Tags # docker # bitnami # devops # containers 1 reaction Comments Add Comment 3 min read Mastering Docker Commands: A Comprehensive Guide for Developers Chandrashekhar Kachawa Chandrashekhar Kachawa Chandrashekhar Kachawa Follow Oct 18 '25 Mastering Docker Commands: A Comprehensive Guide for Developers # docker # devops # containers # tutorial 1 reaction Comments 2 comments 2 min read Docker on ARM architectures Aviral Srivastava Aviral Srivastava Aviral Srivastava Follow Oct 17 '25 Docker on ARM architectures # architecture # containers # docker 1 reaction Comments Add Comment 5 min read Second Experience with Apple Containers! Alain Airom Alain Airom Alain Airom Follow Oct 17 '25 Second Experience with Apple Containers! # containers # containerization # apple 1 reaction Comments Add Comment 4 min read AWS ECS Managed Instances Ryan Batchelder Ryan Batchelder Ryan Batchelder Follow for AWS Community Builders Oct 6 '25 AWS ECS Managed Instances # aws # containers # ecs # ec2 3 reactions Comments Add Comment 4 min read Docker vs. nerdctl: Understanding the Modern Container Landscape omkar shelke omkar shelke omkar shelke Follow Oct 17 '25 Docker vs. nerdctl: Understanding the Modern Container Landscape # containers # kubernetes # nerdctl # docker 6 reactions Comments Add Comment 4 min read Kubernetes v1.34: Top 5 Game-Changing Updates That Will Transform Your Container Strategy Shani Shoham Shani Shoham Shani Shoham Follow Sep 17 '25 Kubernetes v1.34: Top 5 Game-Changing Updates That Will Transform Your Container Strategy # kubernetes # containers # cloud 1 reaction Comments Add Comment 7 min read Automated PostgreSQL Backups in Docker: Complete Guide with pg_dump Max Diamond Max Diamond Max Diamond Follow Sep 12 '25 Automated PostgreSQL Backups in Docker: Complete Guide with pg_dump # postgres # docker # webdev # containers Comments Add Comment 5 min read Presentation: Building Scalable Data Pipelines with Docker and Docker Compose Lagat Josiah Lagat Josiah Lagat Josiah Follow Oct 15 '25 Presentation: Building Scalable Data Pipelines with Docker and Docker Compose # docker # containers # kafka 3 reactions Comments Add Comment 3 min read Reducing EKS cross-AZ cost using Cilium Hardeep Singh Tiwana Hardeep Singh Tiwana Hardeep Singh Tiwana Follow Oct 14 '25 Reducing EKS cross-AZ cost using Cilium # cilium # kubernetes # aws # containers 3 reactions Comments Add Comment 5 min read Linux Namespaces: Network, UTS, and IPC Ajinkya Singh Ajinkya Singh Ajinkya Singh Follow Oct 12 '25 Linux Namespaces: Network, UTS, and IPC # docker # containers # linux # devops 2 reactions Comments 2 comments 3 min read 40 Docker & Kubernetes Interview Questions You Can't Afford to Skip Manish Kumar Manish Kumar Manish Kumar Follow Oct 13 '25 40 Docker & Kubernetes Interview Questions You Can't Afford to Skip # docker # kubernetes # containers # devops 1 reaction Comments Add Comment 11 min read 100 Days of DevOps: Day 68 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Oct 13 '25 100 Days of DevOps: Day 68 # devops # kubernetes # containers # redis 1 reaction Comments Add Comment 3 min read deploy application with Kubernetes k8s in Azure Chabba Saad Chabba Saad Chabba Saad Follow Oct 24 '25 deploy application with Kubernetes k8s in Azure # docker # azure # kubernetes # containers 1 reaction Comments 2 comments 1 min read 🐳 Mastering Dockerfile: A Complete Beginner’s Guide to Building Containers lalith_charan lalith_charan lalith_charan Follow Sep 13 '25 🐳 Mastering Dockerfile: A Complete Beginner’s Guide to Building Containers # devops # docker # dockerfile # containers 1 reaction Comments Add Comment 2 min read Local LLMs: Running Ollama and Open WebUI in Docker on Ubuntu Paul Yu Paul Yu Paul Yu Follow Oct 8 '25 Local LLMs: Running Ollama and Open WebUI in Docker on Ubuntu # ollama # openwebui # containers # ubuntu 17 reactions Comments 1 comment 7 min read Containerization for Data Engineering: A Practical Guide with Docker and Docker Compose Eric Kahindi Eric Kahindi Eric Kahindi Follow Oct 13 '25 Containerization for Data Engineering: A Practical Guide with Docker and Docker Compose # dataengineering # containers # tutorial # docker Comments Add Comment 5 min read Data Engineering with Docker: A Hands-On Guide to Containerization Aineah Simiyu Aineah Simiyu Aineah Simiyu Follow Oct 12 '25 Data Engineering with Docker: A Hands-On Guide to Containerization # docker # containers # dataengineering # automation 7 reactions Comments 2 comments 3 min read Learning Outside Your Specialty \| Why I Got a Kubernetes Cert Danielle Heberling Danielle Heberling Danielle Heberling Follow Oct 12 '25 Learning Outside Your Specialty \| Why I Got a Kubernetes Cert # cloud # kubernetes # containers # certifications Comments Add Comment 3 min read 🛡️Implementing Pod Security Admission in Kubernetes Santhosh S Santhosh S Santhosh S Follow Sep 30 '25 🛡️Implementing Pod Security Admission in Kubernetes # containers # kubernetes # security 1 reaction Comments Add Comment 2 min read Containers Made Simple: No more ‘It Works on My Machine’ Shaquille Niekerk Shaquille Niekerk Shaquille Niekerk Follow Oct 9 '25 Containers Made Simple: No more ‘It Works on My Machine’ # docker # kubernetes # containers # beginners 1 reaction Comments 1 comment 4 min read 100 Days of DevOps: Day 67 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Oct 9 '25 100 Days of DevOps: Day 67 # devops # kubernetes # linux # containers 1 reaction Comments Add Comment 3 min read Docker in a Nutshell: Security Felicity Lois Felicity Lois Felicity Lois Follow Oct 8 '25 Docker in a Nutshell: Security # containers # devops # security # docker Comments Add Comment 3 min read Linux Mount Namespaces and nsenter: Deep Dive Ajinkya Singh Ajinkya Singh Ajinkya Singh Follow Oct 8 '25 Linux Mount Namespaces and nsenter: Deep Dive # docker # containers # linux # programming 1 reaction Comments 3 comments 5 min read 100 Days of DevOps: Day 66 Wycliffe A. Onyango Wycliffe A. Onyango Wycliffe A. Onyango Follow Oct 8 '25 100 Days of DevOps: Day 66 # devops # mysql # kubernetes # containers 1 reaction Comments Add Comment 3 min read loading... 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — Your community HQ Home About Contact Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a blogging-forward open source social network where we learn from one another Log in Create account	2026-01-13T08:49:47
https://discuss.opensource.org/tag/regulation	Topics tagged regulation OSI Discuss regulation Topic Replies Views Activity Is it possible to create a license based on 0BSD + extra development duties? General regulation ,  clearlydefined ,  standards ,  question 0 47 November 16, 2025 Time to fix the rules about European standards? Policy standards ,  europe ,  regulation 2 1735 July 25, 2024 We offered to help with the CRA and the regulators listened! Policy europe ,  regulation 0 773 February 3, 2024 Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://dev.to/aws-builders/identify-design-principles-of-the-aws-cloud-jo	Identify Design Principles of the AWS Cloud - DEV Community Forem Feed Follow new Subforems to improve your feed DEV Community Follow A space to discuss and keep up software development and manage your software career Future Follow News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more. Open Forem Follow A general discussion space for the Forem community. If it doesn't have a home elsewhere, it belongs here Gamers Forem Follow An inclusive community for gaming enthusiasts Music Forem Follow From composing and gigging to gear, hot music takes, and everything in between. Vibe Coding Forem Follow Discussing AI software development, and showing off what we're building. Popcorn Movies and TV Follow Movie and TV enthusiasm, criticism and everything in-between. DUMB DEV Community Follow Memes and software development shitposting Design Community Follow Web design, graphic design and everything in-between Security Forem Follow Your central hub for all things security. From ethical hacking and CTFs to GRC and career development, for beginners and pros alike Golf Forem Follow A community of golfers and golfing enthusiasts Crypto Forem Follow A collaborative community for all things Crypto—from Bitcoin to protocol development and DeFi to NFTs and market analysis. Parenting Follow A place for parents to the share the joys, challenges, and wisdom that come from raising kids. We're here for them and for each other. Forem Core Follow Discussing the core forem open source software project — features, bugs, performance, self-hosting. Maker Forem Follow A community for makers, hobbyists, and professionals to discuss Arduino, Raspberry Pi, 3D printing, and much more. HMPL.js Forem Follow For developers using HMPL.js to build fast, lightweight web apps. A space to share projects, ask questions, and discuss server-driven templating Dropdown menu Dropdown menu Skip to content Navigation menu Search Powered by Algolia Search Log in Create account DEV Community Close Add reaction Like Unicorn Exploding Head Raised Hands Fire Jump to Comments Save Boost More... Copy link Copy link Copied to Clipboard Share to X Share to LinkedIn Share to Facebook Share to Mastodon Share Post via... Report Abuse Ntombizakhona Mabaso for AWS Community Builders Posted on Dec 28, 2025 • Edited on Jan 1           Identify Design Principles of the AWS Cloud # aws # cloud # cloudcomputing # cloudpractitioner Exam Guide: Cloud Practitioner (22 Part Series) 1 Cloud Practitioner Exam Guide 2 Define the Benefits of the AWS Cloud ... 18 more parts... 3 Identify Design Principles of the AWS Cloud 4 Understand the Benefits of and Strategies for Migration to the AWS Cloud 5 Understand Concepts of Cloud Economics 6 Understand the AWS Shared Responsibility Model 7 Understand AWS Cloud Security, Governance, and Compliance Concepts 8 Identify AWS Access Management Capabilities 9 Identify Components and Resources for Security 10 Define Methods of Deploying and Operating in the AWS Cloud 11 Define the AWS Global Infrastructure 12 Identify AWS Compute Services 13 Identify AWS Database Services 14 Identify AWS Network Services 15 Identify AWS Storage Services 16 Identify AWS Artificial Intelligence and Machine Learning (AI/ML) Services And Analytics Services 17 Identify Services From Other In-Scope AWS Service Categories 18 Compare AWS Pricing Models 19 Understand Resources For Billing, Budget, and Cost Management 20 Identify AWS Technical Resources And AWS Support Options 21 Technologies and Concepts: Cloud Practitioner (CLF-C02) 22 My Cloud Practitioner Certification Journey and the Resources to Certify with Confidence ☁️ Exam Guide: Cloud Practitioner Domain 1: Cloud Concepts 📘 Task Statement 1.2 🎯 What Is This Task Testing? This objective checks whether you understand the AWS Well-Architected Framework and can: Describe the six pillars Explain what each pillar focuses on Differentiate between pillars when scenarios sound similar (common exam trap) 🧠 AWS Well-Architected Framework (WA Framework) The AWS Well-Architected Framework is AWS guidance for building cloud architectures that are: secure and resilient efficient and cost-effective operationally manageable aligned with sustainability goals It is organized into six pillars , each representing a major area of design decisions and trade-offs. 🧱 The Six Pillars 1) Operational Excellence 🔧 What is Operational Excellence? Running and monitoring systems, improving processes, and delivering changes safely. What it includes: operations as code (repeatable, automated processes) monitoring, incident response, post-incident learning continuous improvement Words Associated With The Operational Excellence Pillar: monitoring, automation, runbooks, deployments, incident response. 2) Security 🔒 What is Security? Protecting data, systems, and assets, managing risk. What it includes: identity and access management (least privilege) detection (logging/monitoring for threats) infrastructure protection data protection (encryption) incident response Words Associated With The Security Pillar: IAM, permissions, encryption, audit logs, threat detection. 3) Reliability 🛡️ What is Reliability? Consistently delivering intended functionality and recovering from failures. What it includes: fault-tolerant design recovery planning and testing handling change and scaling designing to prevent and mitigate failures Words Associated With The Reliability Pillar: failover, redundancy, backups/restore, disaster recovery, multi-AZ. 4) Performance Efficiency ⚡ What is Performance Efficiency? Using computing resources efficiently to meet system requirements as demand changes. What it includes: choosing the right resource types and sizes using managed services where possible monitoring performance and making data-driven improvements evolving with new AWS services/features Words Associated With The Performance Efficiency Pillar: latency, throughput, right-sizing for performance, selection of instance types, caching. 5) Cost Optimization 💰 What is Cost Optimization? Avoiding unnecessary costs and getting the best value. What it includes: right-sizing to reduce waste measuring and attributing spend (cost visibility) using cost-effective pricing models (e.g., Savings Plans/Reserved Instances when appropriate) turning off unused resources Words Associated With The Cost Optimization Pillar: reduce bill, eliminate idle, budgeting, cost allocation tags, “cheapest option”. 6) Sustainability 🌱 What is Sustainability? Minimizing environmental impact and improving energy efficiency. What it includes: using managed services and efficient architectures optimizing resource utilization (scale only when needed) selecting Regions based on sustainability needs (where applicable) reducing overall compute/storage/network waste Words Associated With The Sustainability Pillar: carbon footprint, energy usage, reduce waste, efficient resource utilization. How to Identify Differences Between Pillars 🧭 These pillars often overlap, but the exam usually wants the best match : Reliability vs Operational Excellence Reliability: “Will it stay up and recover?” (fault tolerance, DR, failover) Operational Excellence: “Can we run and improve it well?” (monitoring, processes, automation, learning) Performance Efficiency vs Cost Optimization Performance Efficiency: “Is it fast/efficient for requirements?” (latency, throughput, choosing the right tech) Cost Optimization: “Are we spending the least for required value?” (right-sizing to reduce bill, pricing models) Security vs Reliability Security: access control, encryption, detection, compliance Reliability: resilience, recovery, availability Sustainability vs Cost Optimization Sustainability: reduce environmental impact/energy use Cost Optimization: reduce monetary cost ✅ Quick Exam-Style Summary Understand each pillar’s primary aim: Operational Excellence: run, monitor, improve operations Security: protect identities, data, and systems Reliability: prevent failures and recover quickly Performance Efficiency: meet performance needs with efficient resource choices Cost Optimization: eliminate waste and control spending Sustainability: reduce energy use and environmental impact Additional Resources AWS Well-Architected Framework Exam Guide: Cloud Practitioner (22 Part Series) 1 Cloud Practitioner Exam Guide 2 Define the Benefits of the AWS Cloud ... 18 more parts... 3 Identify Design Principles of the AWS Cloud 4 Understand the Benefits of and Strategies for Migration to the AWS Cloud 5 Understand Concepts of Cloud Economics 6 Understand the AWS Shared Responsibility Model 7 Understand AWS Cloud Security, Governance, and Compliance Concepts 8 Identify AWS Access Management Capabilities 9 Identify Components and Resources for Security 10 Define Methods of Deploying and Operating in the AWS Cloud 11 Define the AWS Global Infrastructure 12 Identify AWS Compute Services 13 Identify AWS Database Services 14 Identify AWS Network Services 15 Identify AWS Storage Services 16 Identify AWS Artificial Intelligence and Machine Learning (AI/ML) Services And Analytics Services 17 Identify Services From Other In-Scope AWS Service Categories 18 Compare AWS Pricing Models 19 Understand Resources For Billing, Budget, and Cost Management 20 Identify AWS Technical Resources And AWS Support Options 21 Technologies and Concepts: Cloud Practitioner (CLF-C02) 22 My Cloud Practitioner Certification Journey and the Resources to Certify with Confidence Top comments (0) Subscribe Personal Trusted User Create template Templates let you quickly answer FAQs or store snippets for re-use. Submit Preview Dismiss Code of Conduct • Report abuse Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink . Hide child comments as well Confirm For further actions, you may consider blocking this person and/or reporting abuse AWS Community Builders Follow Build On! Would you like to become an AWS Community Builder? Learn more about the program and apply to join when applications are open next. Learn more More from AWS Community Builders Tag log buckets created by AWS CDK for third party tools # aws # cdk # cdknag It’s 2026: Stop Using AWS IAM and Start Using IAM Identity Center # aws # tutorial # devops # cloud AWS Community Builder 2026 - Applications Open !! # aws # community # kiro # ai 💎 DEV Diamond Sponsors Thank you to our Diamond Sponsors for supporting the DEV Community Google AI is the official AI Model and Platform Partner of DEV Neon is the official database partner of DEV Algolia is the official search partner of DEV DEV Community — A space to discuss and keep up software development and manage your software career Home DEV++ Podcasts Videos DEV Education Tracks DEV Challenges DEV Help Advertise on DEV DEV Showcase About Contact Free Postgres Database Software comparisons Forem Shop Code of Conduct Privacy Policy Terms of Use Built on Forem — the open source software that powers DEV and other inclusive communities. Made with love and Ruby on Rails . DEV Community © 2016 - 2026. We're a place where coders share, stay up-to-date and grow their careers. Log in Create account	2026-01-13T08:49:47
https://discuss.opensource.org/tag/clearlydefined	Topics tagged clearlydefined OSI Discuss clearlydefined Topic Replies Views Activity Is it possible to create a license based on 0BSD + extra development duties? General regulation ,  clearlydefined ,  standards ,  question 0 47 November 16, 2025 Sybase open watcom and reciprocal public license General standards ,  clearlydefined 1 111 December 30, 2024 ClearlyDefined at SOSS Fusion 2024: a collaborative solution to Open Source license compliance General events ,  clearlydefined 0 97 November 8, 2024 Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/tag/standards	Topics tagged standards OSI Discuss standards Topic Replies Views Activity Is it possible to create a license based on 0BSD + extra development duties? General regulation ,  clearlydefined ,  standards ,  question 0 47 November 16, 2025 `curl \| bash`: Trust as a privilege? General standards 1 277 April 22, 2025 Sybase open watcom and reciprocal public license General standards ,  clearlydefined 1 111 December 30, 2024 Time to fix the rules about European standards? Policy standards ,  europe ,  regulation 2 1735 July 25, 2024 Fixing a loophole in the proposed EU SEP Regulation Policy standards ,  patents ,  europe 0 411 February 1, 2024 Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/tag/question	Topics tagged question OSI Discuss question Topic Replies Views Activity Is it possible to create a license based on 0BSD + extra development duties? General regulation ,  clearlydefined ,  standards ,  question 0 47 November 16, 2025 Opensource Licensing: Prevent hijacking General question 1 105 November 7, 2025 About the open-source definition General question 1 110 June 4, 2025 What do you think of the Open Source AI Definition? Elections question 19 452 March 27, 2025 What do you think of the Board Agreement? Elections question 26 708 March 20, 2025 What ideas do you have to sustain and expand OSI's fundraising initiatives? Elections question 6 200 March 9, 2025 Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/t/open-letter-harnessing-open-source-ai-to-advance-digital-sovereignty/1326	Open letter: Harnessing open source AI to advance digital sovereignty - Open Source AI - OSI Discuss OSI Discuss Open letter: Harnessing open source AI to advance digital sovereignty Open Source AI system November 20, 2025, 11:06am 1 Originally published at: Open letter: Harnessing open source AI to advance digital sovereignty – Open Source Initiative Europe is at a crossroads. The Summit on European Digital Sovereignty marks an important milestone for the EU and its member states in aligning on a shared strategy for achieving real and lasting European digital sovereignty. As the EU pursues the goal of digital sovereignty, we urge you to harness open source — that is, technology that is free to use, inspect, adapt, and share — as a key enabler of this strategy. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://opensource.org/license/apache-1-1	Apache Software License, version 1.1 – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Superseded Apache Software License, version 1.1 Version 1.1 Board minutes SPDX short identifier: Apache-1.1 (Note: This license has been superseded by the Apache License, Version 2.0 ) Copyright (c) 2000 The Apache Software Foundation. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. The end-user documentation included with the redistribution, if any, must include the following acknowledgment: “This product includes software developed by the Apache Software Foundation (http://www.apache.org/).” Alternately, this acknowledgment may appear in the software itself, if and wherever such third-party acknowledgments normally appear. 4. The names “Apache” and “Apache Software Foundation” must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact [email protected] . 5. Products derived from this software may not be called “Apache”, nor may “Apache” appear in their name, without prior written permission of the Apache Software Foundation. THIS SOFTWARE IS PROVIDED “AS IS” AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This software consists of voluntary contributions made by many individuals on behalf of the Apache Software Foundation. For more information on the Apache Software Foundation, please see <http://www.apache.org/>. Portions of this software are based upon public domain software originally written at the National Center for Supercomputing Applications, University of Illinois, Urbana-Champaign. Donate to the OSI The OSI is the authority that defines Open Source, recognized globally by individuals, companies, and public institutions. The Open Source Initiative (OSI) is a 501(c)3 public benefit corporation, founded in 1998. --> Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:47
https://opensource.org/?p=775	Affiliate Organizations – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Home Affiliate Organizations OSI Affiliate organizations are nonprofit organizations, open source projects & communities, educational institutions (K12 & Higher Ed.), and user groups engaged in and with the open source community. To become an Affiliate is an ideal way for open source projects, and the communities that support them, to promote and extend the OSI mission , and contribute to the continued awareness and adoption of Open Source Software. If your organization believes in Open Source Software and your community wants to support our work, like all of the dedicated organizations listed below, please consider joining . List of Affiliate organizations Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:47
https://developers.facebook.com/?ref=pf	소셜 테크놀로지 \| Meta for Developers 소셜 테크놀로지 사람들이 친구 및 가족과 소통하고 커뮤니티를 찾고 비즈니스를 성장시키는 데 도움이 되는 테크놀로지를 개발하세요. 시작하기 모든 제품 둘러보기 문서 둘러보기 개발자 도구 지원 받기 새로운 소식 함께 성장하기 Facebook, Instagram, Messenger, WhatsApp, Threads에서 창작하고 성장하고 소통하는 데 도움이 될 수 있는 저희의 소셜 테크놀로지 솔루션에 대해 자세히 알아보세요. Facebook Messenger Instagram WhatsApp Threads 성공 사례 2억 이상의 비즈니스가 매달 저희 서비스를 이용하여 고객과 소통하며 성장하고 있습니다. Avid Empowers media creators with innovative technology and collaborative tools to entertain, inform, educate and enlighten the world. Learn more Universal Pictures Engaging fans through interactive multimedia messaging campaigns. Learn more Housing Development Finance Corporation Developing a faster, simpler and convenient way to help customers determine their home loan eligibility. Learn more 성공 사례 보기 모든 제품 둘러보기 소셜 테크놀로지는 여러분이 성장하고 커뮤니티를 만들고 앱을 수익화하는 데 도움이 될 수 있는 다양한 솔루션을 제공합니다. 광고 및 수익화 Meta 광고 및 수익화 솔루션으로 수십억에 달하는 사람들에게 도달하여 비즈니스 성장을 이루세요. 개요 인공 지능 업계를 선도하는 접근성 높은 공개 AI 도구를 활용하여 원하는 규모를 실현하세요. 개요 인증 탄탄한 권한 부여 프로토콜이 뒷받침되는 편리하고 안전한 인증 방법을 구현하세요. 개요 비즈니스 메시지 적시에 적절한 사람들에게 적절한 메시지를 보내 대화를 바탕으로 더 큰 성과를 올리세요. 개요 게이밍 혁신적인 게이밍 플랫폼과 서비스 제품군에 액세스하세요. 개요 오픈 소스 오픈 소스 기술로 커뮤니티를 지원하세요. 개요 소셜 통합 Meta 테크놀로지를 저희의 소셜 통합 기능과 함께 사용하여 수십억에 달하는 사람들과 소통하고 이들의 참여를 유도하세요. 개요 모든 제품 둘러보기 최신 소식 2025년 10월 16일 Ads Insights API Metric Availability Updates We continuously review the metrics we offer advertisers to ensure that they are accurate, intuitive, and valuable. To continue meeting our high standards, we will limit availability for certain metrics’ available attribution windows and breakdowns in the Ads Insights API beginning on January 12, 2026. Below, please find details relevant to the... 비즈니스 도구 2025년 10월 8일 Introducing Graph API v24.0 and Marketing API v24.0 Here are the highlights of the new GAPI/MAPI changes below for V24. Please visit our changelog for a complete list of changes and details.General Updates... 비즈니스 도구, 그래프 API, 마케팅 API 2025년 10월 8일 Introducing Limited Spend on Excluded Placements in Marketing API Starting October 8th, we’re rolling out a new feature within placements that allows up to 5% of your spend to be allocated for each excluded placement—when it’s likely to improve performance. This update provides you with flexibility to have some delivery to specific placements, without requiring you to completely remove placements from your... 비즈니스 도구, 마케팅 API 블로그 게시물 더 보기 뉴스레터 구독 월간 Meta for Developers 뉴스레터를 구독하세요. 신청하기 -->	2026-01-13T08:49:47
https://opensource.org/license/cecill-2-1	Cea Cnrs Inria Logiciel Libre License, version 2.1 – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu International Cea Cnrs Inria Logiciel Libre License, version 2.1 Version 2.1 Submitted: February 27, 2012 Submitter: Patrick Moreau, URL N/A Approved: May 1, 2013 Board minutes SPDX short identifier: CECILL-2.1 Steward: CEA CNRS INRIA Logiciel Libre This license is also available in French from the CeCILL website . Version 2.1 dated 2013-06-21 Notice This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting: firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users, secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software. The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre]) license are: Commissariat à l’énergie atomique et aux énergies – CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France. Centre National de la Recherche Scientifique – CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France. Institut National de Recherche en Informatique et en Automatique – Inria, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France. Preamble The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model. The exercising of this right is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions. In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software’s author, the holder of the economic rights, and the successive licensors only have limited liability. In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user’s attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom. This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions. Frequently asked questions can be found on the official website of the CeCILL licenses family (http://www.cecill.info/index.en.html) for any necessary clarification. Article 1 – DEFINITIONS For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning: Agreement: means this license agreement, and its possible subsequent versions and annexes. Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, “as is” when the Licensee accepts the Agreement. Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, “as is” when it is first distributed under the terms and conditions of the Agreement. Modified Software: means the Software modified by at least one Contribution. Source Code: means all the Software’s instructions and program lines to which access is required so as to modify the Software. Object Code: means the binary files originating from the compilation of the Source Code. Holder: means the holder(s) of the economic rights over the Initial Software. Licensee: means the Software user(s) having accepted the Agreement. Contributor: means a Licensee having made at least one Contribution. Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement. Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules. Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software. External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run. Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space. GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc. GNU Affero GPL: means the GNU Affero General Public License version 3 or any subsequent version, as published by the Free Software Foundation Inc. EUPL: means the European Union Public License version 1.1 or any subsequent version, as published by the European Commission. Parties: mean both the Licensee and the Licensor. These expressions may be used both in singular and plural form. Article 2 – PURPOSE The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software. Article 3 – ACCEPTANCE 3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events: (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium; (ii) the first time the Licensee exercises any of the rights granted hereunder. 3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it. Article 4 – EFFECTIVE DATE AND TERM 4.1 EFFECTIVE DATE The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1. 4.2 TERM The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software. Article 5 – SCOPE OF RIGHTS GRANTED The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter. Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph. 5.1 RIGHT OF USE The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises: permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form. loading, displaying, running, or storing the Software on any or all medium. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder. 5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software. The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof. 5.3 RIGHT OF DISTRIBUTION In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means. The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter. 5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: a copy of the Agreement, a notice relating to the limitation of both the Licensor’s warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows effective access to the full Source Code of the Software for a period of at least three years from the distribution of the Software, it being understood that the additional acquisition cost of the Source Code shall not exceed the cost of the data transfer. 5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement. The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: a copy of the Agreement, a notice relating to the limitation of both the Licensor’s warranty and liability as set forth in Articles 8 and 9, and, in the event that only the object code of the Modified Software is redistributed, a note stating the conditions of effective access to the full source code of the Modified Software for a period of at least three years from the distribution of the Modified Software, it being understood that the additional acquisition cost of the source code shall not exceed the cost of the data transfer. 5.3.3 DISTRIBUTION OF EXTERNAL MODULES When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement. 5.3.4 COMPATIBILITY WITH OTHER LICENSES The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL, GNU Affero GPL and/or EUPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL. The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, GNU Affero GPL and/or EUPL and distribute that entire code under the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL. Article 6 – INTELLECTUAL PROPERTY 6.1 OVER THE INITIAL SOFTWARE The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software. The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2. 6.2 OVER THE CONTRIBUTIONS The Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law. 6.3 OVER THE EXTERNAL MODULES The Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution. 6.4 JOINT PROVISIONS The Licensee expressly undertakes: not to remove, or modify, in any manner, the intellectual property notices attached to the Software; to reproduce said notices, in an identical manner, in the copies of the Software modified or not. The Licensee undertakes not to directly or indirectly infringe the intellectual property rights on the Software of the Holder and/or Contributors, and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors. Article 7 – RELATED SERVICES 7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software. However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor. 7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee. Article 8 – LIABILITY 8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof. 8.2 The Licensor’s liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee’s total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor. Article 9 – WARRANTY 9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee’s attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users. The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties. 9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5). 9.3 The Licensee acknowledges that the Software is supplied “as is” by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature. Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee’s own equipment and software configuration, nor that it will meet the Licensee’s requirements. 9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal expertise for its defense. Such technical and legal expertise shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee’s use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark. Article 10 – TERMINATION 10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective. 10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof. Article 11 – MISCELLANEOUS 11.1 EXCUSABLE EVENTS Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc. 11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently. 11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives. 11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid. 11.5 LANGUAGE The Agreement is drafted in both French and English and both versions are deemed authentic. Article 12 – NEW VERSIONS OF THE AGREEMENT 12.1 Any person is authorized to duplicate and distribute copies of this Agreement. 12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software. 12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4. Article 13 – GOVERNING LAW AND JURISDICTION 13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement. 13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party. Donate to the OSI The OSI is the authority that defines Open Source, recognized globally by individuals, companies, and public institutions. The Open Source Initiative (OSI) is a 501(c)3 public benefit corporation, founded in 1998. --> Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:47
https://discuss.opensource.org/t/artificial-analysis-openness-index/1350	Artificial Analysis Openness Index - Open Source AI - OSI Discuss OSI Discuss Artificial Analysis Openness Index Open Source AI moodler January 8, 2026, 9:25am 1 Just discovered this nice analysis of the relative “openness” of different LLMs and thought of you all. Cheers! artificialanalysis.ai – 1 Dec 25 Introducing the Artificial Analysis Openness Index An industry-standard measure of how open AI models are across both usage and transparency Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/t/sustaining-open-source-the-next-25-years-depend-on-what-we-do-together-now/1325	Sustaining Open Source: The Next 25 Years Depend on What We Do Together Now - General - OSI Discuss OSI Discuss Sustaining Open Source: The Next 25 Years Depend on What We Do Together Now General system November 18, 2025, 12:32pm 1 Originally published at: Sustaining Open Source: The Next 25 Years Depend on What We Do Together Now – Open Source Initiative Open source is suffering from its own success. The ecosystem that once thrived on volunteer energy now faces existential questions: How do we sustain the infrastructure that powers the modern world? The answer isn’t just money—it’s people, governance, and collaboration. We need companies to invest not only funds but also employee time, foundations to work together instead of in silos, and communities to plan for the full lifecycle of projects. The next 25 years depend on what we do together now. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/t/must-see-recordings-now-available/1320	Must-See Recordings Now Available - General - OSI Discuss OSI Discuss Must-See Recordings Now Available General system November 6, 2025, 2:09pm 1 Originally published at: Must-See Recordings Now Available – Open Source Initiative Members Newsletter – November 2025 October was punctuated by lots of direct connections with the community. In this month’s newsletter, we’ll highlight our experience through our annual “State of the Source” track at All Things Open; discuss our advocacy on behalf of the Open Source community through our public policy work; and share the recorded sessions from outstanding contributors to the Deep Dive: Data Governance virtual event. 1 Like Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/t/opensource-licensing-prevent-hijacking/1321	Opensource Licensing: Prevent hijacking - General - OSI Discuss OSI Discuss Opensource Licensing: Prevent hijacking General question CodeShell November 7, 2025, 10:13am 1 Hello everyone, I am using MIT for my foss projects, but I want to add a few things: any fork should credit all of the contributors, and must not change authors of commits forks must not leave the fork network if they dont add anything forks outside of fork network must not use the original Repo name I want to add these terms to prevent people copying my Repo without forking, then changing the author of all commits and lastly claiming it is their work and using the original name. (Has happened to me) Is this possible, whilst still preserving the opensource principles? Thanks in advance! nick November 7, 2025, 1:52pm 2 Hi @CodeShell , thank you for your questions. While I’m not a lawyer, I believe the only way to protect your project name (or Brand) would be through trademarks (not through Open Source licenses). As for given credit to contributors (or attribution) this is very much aligned with Open Source principles. Since you are using the MIT license , you may add an attribution notice or a list of original contributors. A license like Apache 2.0 might be a better fit because it explicitly states that one must respect attribution (and trademarks, among other things). While I’m sympathetic to your frustration with people who copy your project and claim it as their own work (that’s definitely a no-no), please note that restricting distribution (or forks) of your project does not meet the Open Source Definition . So the solution is not to limit forking, but to ensure proper attribution and protect your project name via trademark. 1 Like Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/t/top-open-source-licenses-in-2025/1338	Top Open Source licenses in 2025 - General - OSI Discuss OSI Discuss Top Open Source licenses in 2025 General system December 17, 2025, 6:09pm 1 Originally published at: Top Open Source licenses in 2025 – Open Source Initiative The top 20 OSI-Approved licenses most frequently sought out by our community in 2025 based on number of pageviews. shujisado December 28, 2025, 12:39pm 2 Annual license page view rankings are usually pretty predictable and, frankly, a bit boring. However, if you look closely at this year’s data, some fascinating trends emerge – specifically the entry of the zlib license into the top rankings and the significant climb of 0BSD . Seeing zlib, which is typically a niche license, gain this much traction is genuinely surprising. The driving force behind this is AI. While the zlib license is a permissive license similar to MIT, its standout feature is that it does not require copyright attribution for products. In the world of AI models, where managing individual attributions for every component can be a massive headache, zlib has likely gained attention as a pragmatic solution. We see a similar story with 0BSD. It goes a step further by removing the attribution requirement entirely. In the past, people opted for the Unlicense or CC0 for “public domain-like” software, but those can run into legal gray areas in jurisdictions where you can’t easily waive copyrights. 0BSD solves this by remaining a formal license while functioning as a de facto public domain grant. It’s perfectly suited for the AI era. I expect this trend toward “attribution-light” licenses to only get stronger next year. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://discuss.opensource.org/t/celebrating-generosity-and-growth-in-the-osi-community/1336	Celebrating Generosity and Growth in the OSI Community - General - OSI Discuss OSI Discuss Celebrating Generosity and Growth in the OSI Community General system December 12, 2025, 1:10pm 1 Originally published at: Celebrating Generosity and Growth in the OSI Community – Open Source Initiative Members Newsletter – December 2025 As we reach the final weeks of the year, I find myself reflecting on a season that invites both gratitude and giving, two values that feel especially resonant for our community. Serving as Interim Executive Director these past months has only deepened my appreciation for the people who make Open Source possible. Home Categories Guidelines Terms of Service Privacy Policy Powered by Discourse , best viewed with JavaScript enabled	2026-01-13T08:49:47
https://llvm.org/docs/LangRef.html#pointer-aliasing-rules	LLVM Language Reference Manual — LLVM 22.0.0git documentation Navigation index next \| previous \| LLVM Home  \|  Documentation » Reference » LLVM Language Reference Manual Documentation Getting Started/Tutorials User Guides Reference Getting Involved Contributing to LLVM Submitting Bug Reports Mailing Lists Discord Meetups and Social Events Additional Links FAQ Glossary Publications Github Repository This Page Show Source Quick search LLVM Language Reference Manual ¶ Abstract Introduction Well-Formedness Syntax Identifiers String constants High Level Structure Module Structure Linkage Types Calling Conventions Visibility Styles DLL Storage Classes Thread Local Storage Models Runtime Preemption Specifiers Structure Types Non-Integral Pointer Type Pointers with non-address bits Unstable pointer representation Pointers with external state Global Variables Functions Aliases IFuncs Comdats Named Metadata Parameter Attributes Garbage Collector Strategy Names Prefix Data Prologue Data Personality Function Attribute Groups Function Attributes Call Site Attributes Global Attributes Operand Bundles Deoptimization Operand Bundles Funclet Operand Bundles GC Transition Operand Bundles Assume Operand Bundles Preallocated Operand Bundles GC Live Operand Bundles ObjC ARC Attached Call Operand Bundles Pointer Authentication Operand Bundles KCFI Operand Bundles Convergence Control Operand Bundles Deactivation Symbol Operand Bundles Module-Level Inline Assembly Data Layout Target Triple Allocated Objects Object Lifetime Pointer Aliasing Rules Pointer Capture Volatile Memory Accesses Memory Model for Concurrent Operations Atomic Memory Ordering Constraints Floating-Point Environment Behavior of Floating-Point NaN values Floating-Point Semantics Fast-Math Flags Rewrite-based flags Use-list Order Directives Source Filename Type System Void Type Function Type Opaque Structure Types First Class Types Single Value Types Label Type Token Type Metadata Type Aggregate Types Constants Simple Constants Complex Constants Global Variable and Function Addresses Undefined Values Poison Values Well-Defined Values Addresses of Basic Blocks DSO Local Equivalent No CFI Pointer Authentication Constants Constant Expressions Other Values Inline Assembler Expressions Inline Asm Constraint String Asm template argument modifiers Inline Asm Metadata Metadata Metadata Strings ( MDString ) Metadata Nodes ( MDNode ) Specialized Metadata Nodes ‘ tbaa ’ Metadata ‘ tbaa.struct ’ Metadata ‘ noalias ’ and ‘ alias.scope ’ Metadata ‘ fpmath ’ Metadata ‘ range ’ Metadata ‘ absolute_symbol ’ Metadata ‘ callees ’ Metadata ‘ callback ’ Metadata ‘ exclude ’ Metadata ‘ unpredictable ’ Metadata ‘ dereferenceable ’ Metadata ‘ dereferenceable_or_null ’ Metadata ‘ captures ’ Metadata ‘ llvm.loop ’ ‘ llvm.loop.disable_nonforced ’ ‘ llvm.loop.vectorize ’ and ‘ llvm.loop.interleave ’ ‘ llvm.loop.interleave.count ’ Metadata ‘ llvm.loop.vectorize.enable ’ Metadata ‘ llvm.loop.vectorize.predicate.enable ’ Metadata ‘ llvm.loop.vectorize.scalable.enable ’ Metadata ‘ llvm.loop.vectorize.width ’ Metadata ‘ llvm.loop.vectorize.followup_vectorized ’ Metadata ‘ llvm.loop.vectorize.followup_epilogue ’ Metadata ‘ llvm.loop.vectorize.followup_all ’ Metadata ‘ llvm.loop.unroll ’ ‘ llvm.loop.unroll.count ’ Metadata ‘ llvm.loop.unroll.disable ’ Metadata ‘ llvm.loop.unroll.runtime.disable ’ Metadata ‘ llvm.loop.unroll.enable ’ Metadata ‘ llvm.loop.unroll.full ’ Metadata ‘ llvm.loop.unroll.followup ’ Metadata ‘ llvm.loop.unroll.followup_remainder ’ Metadata ‘ llvm.loop.unroll_and_jam ’ ‘ llvm.loop.unroll_and_jam.count ’ Metadata ‘ llvm.loop.unroll_and_jam.disable ’ Metadata ‘ llvm.loop.unroll_and_jam.enable ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_outer ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_inner ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_remainder_outer ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_remainder_inner ’ Metadata ‘ llvm.loop.unroll_and_jam.followup_all ’ Metadata ‘ llvm.loop.licm_versioning.disable ’ Metadata ‘ llvm.loop.distribute.enable ’ Metadata ‘ llvm.loop.distribute.followup_coincident ’ Metadata ‘ llvm.loop.distribute.followup_sequential ’ Metadata ‘ llvm.loop.distribute.followup_fallback ’ Metadata ‘ llvm.loop.distribute.followup_all ’ Metadata ‘ llvm.loop.isdistributed ’ Metadata ‘ llvm.loop.estimated_trip_count ’ Metadata ‘ llvm.licm.disable ’ Metadata ‘ llvm.access.group ’ Metadata ‘ llvm.loop.parallel_accesses ’ Metadata ‘ llvm.loop.mustprogress ’ Metadata ‘ irr_loop ’ Metadata ‘ invariant.group ’ Metadata ‘ type ’ Metadata ‘ callee_type ’ Metadata ‘ associated ’ Metadata ‘ prof ’ Metadata ‘ annotation ’ Metadata ‘ func_sanitize ’ Metadata ‘ kcfi_type ’ Metadata ‘ pcsections ’ Metadata ‘ memprof ’ Metadata ‘ callsite ’ Metadata ‘ noalias.addrspace ’ Metadata ‘ mmra ’ Metadata ‘ nofree ’ Metadata ‘ alloc_token ’ Metadata ‘ stack-protector ’ Metadata ‘ implicit.ref ’ Metadata Module Flags Metadata Synthesized Functions Module Flags Metadata Objective-C Garbage Collection Module Flags Metadata C type width Module Flags Metadata Stack Alignment Metadata Embedded Objects Names Metadata Automatic Linker Flags Named Metadata Dependent Libs Named Metadata ‘ llvm.errno.tbaa ’ Named Metadata ThinLTO Summary Module Path Summary Entry Global Value Summary Entry Function Summary Global Variable Summary Alias Summary Function Flags Calls Params Refs TypeIdInfo Type ID Summary Entry Intrinsic Global Variables The ‘ llvm.used ’ Global Variable The ‘ llvm.compiler.used ’ Global Variable The ‘ llvm.global_ctors ’ Global Variable The ‘ llvm.global_dtors ’ Global Variable Instruction Reference Terminator Instructions ‘ ret ’ Instruction ‘ br ’ Instruction ‘ switch ’ Instruction ‘ indirectbr ’ Instruction ‘ invoke ’ Instruction ‘ callbr ’ Instruction ‘ resume ’ Instruction ‘ catchswitch ’ Instruction ‘ catchret ’ Instruction ‘ cleanupret ’ Instruction ‘ unreachable ’ Instruction Unary Operations ‘ fneg ’ Instruction Binary Operations ‘ add ’ Instruction ‘ fadd ’ Instruction ‘ sub ’ Instruction ‘ fsub ’ Instruction ‘ mul ’ Instruction ‘ fmul ’ Instruction ‘ udiv ’ Instruction ‘ sdiv ’ Instruction ‘ fdiv ’ Instruction ‘ urem ’ Instruction ‘ srem ’ Instruction ‘ frem ’ Instruction Bitwise Binary Operations ‘ shl ’ Instruction ‘ lshr ’ Instruction ‘ ashr ’ Instruction ‘ and ’ Instruction ‘ or ’ Instruction ‘ xor ’ Instruction Vector Operations ‘ extractelement ’ Instruction ‘ insertelement ’ Instruction ‘ shufflevector ’ Instruction Aggregate Operations ‘ extractvalue ’ Instruction ‘ insertvalue ’ Instruction Memory Access and Addressing Operations ‘ alloca ’ Instruction ‘ load ’ Instruction ‘ store ’ Instruction ‘ fence ’ Instruction ‘ cmpxchg ’ Instruction ‘ atomicrmw ’ Instruction ‘ getelementptr ’ Instruction Conversion Operations ‘ trunc .. to ’ Instruction ‘ zext .. to ’ Instruction ‘ sext .. to ’ Instruction ‘ fptrunc .. to ’ Instruction ‘ fpext .. to ’ Instruction ‘ fptoui .. to ’ Instruction ‘ fptosi .. to ’ Instruction ‘ uitofp .. to ’ Instruction ‘ sitofp .. to ’ Instruction ‘ ptrtoint .. to ’ Instruction ‘ ptrtoaddr .. to ’ Instruction ‘ inttoptr .. to ’ Instruction ‘ bitcast .. to ’ Instruction ‘ addrspacecast .. to ’ Instruction Other Operations ‘ icmp ’ Instruction ‘ fcmp ’ Instruction ‘ phi ’ Instruction ‘ select ’ Instruction ‘ freeze ’ Instruction ‘ call ’ Instruction ‘ va_arg ’ Instruction ‘ landingpad ’ Instruction ‘ catchpad ’ Instruction ‘ cleanuppad ’ Instruction Debug Records Intrinsic Functions Variable Argument Handling Intrinsics ‘ llvm.va_start ’ Intrinsic ‘ llvm.va_end ’ Intrinsic ‘ llvm.va_copy ’ Intrinsic Accurate Garbage Collection Intrinsics ‘ llvm.gcroot ’ Intrinsic ‘ llvm.gcread ’ Intrinsic ‘ llvm.gcwrite ’ Intrinsic ‘ llvm.experimental.gc.statepoint ’ Intrinsic ‘ llvm.experimental.gc.result ’ Intrinsic ‘ llvm.experimental.gc.relocate ’ Intrinsic ‘ llvm.experimental.gc.get.pointer.base ’ Intrinsic ‘ llvm.experimental.gc.get.pointer.offset ’ Intrinsic Code Generator Intrinsics ‘ llvm.returnaddress ’ Intrinsic ‘ llvm.addressofreturnaddress ’ Intrinsic ‘ llvm.sponentry ’ Intrinsic ‘ llvm.stackaddress ’ Intrinsic ‘ llvm.frameaddress ’ Intrinsic ‘ llvm.swift.async.context.addr ’ Intrinsic ‘ llvm.localescape ’ and ‘ llvm.localrecover ’ Intrinsics ‘ llvm.seh.try.begin ’ and ‘ llvm.seh.try.end ’ Intrinsics ‘ llvm.seh.scope.begin ’ and ‘ llvm.seh.scope.end ’ Intrinsics ‘ llvm.read_register ’, ‘ llvm.read_volatile_register ’, and ‘ llvm.write_register ’ Intrinsics ‘ llvm.stacksave ’ Intrinsic ‘ llvm.stackrestore ’ Intrinsic ‘ llvm.get.dynamic.area.offset ’ Intrinsic ‘ llvm.prefetch ’ Intrinsic ‘ llvm.pcmarker ’ Intrinsic ‘ llvm.readcyclecounter ’ Intrinsic ‘ llvm.readsteadycounter ’ Intrinsic ‘ llvm.clear_cache ’ Intrinsic ‘ llvm.instrprof.increment ’ Intrinsic ‘ llvm.instrprof.increment.step ’ Intrinsic ‘ llvm.instrprof.callsite ’ Intrinsic ‘ llvm.instrprof.timestamp ’ Intrinsic ‘ llvm.instrprof.cover ’ Intrinsic ‘ llvm.instrprof.value.profile ’ Intrinsic ‘ llvm.instrprof.mcdc.parameters ’ Intrinsic ‘ llvm.instrprof.mcdc.tvbitmap.update ’ Intrinsic ‘ llvm.thread.pointer ’ Intrinsic ‘ llvm.call.preallocated.setup ’ Intrinsic ‘ llvm.call.preallocated.arg ’ Intrinsic ‘ llvm.call.preallocated.teardown ’ Intrinsic Standard C/C++ Library Intrinsics ‘ llvm.abs.* ’ Intrinsic ‘ llvm.smax.* ’ Intrinsic ‘ llvm.smin.* ’ Intrinsic ‘ llvm.umax.* ’ Intrinsic ‘ llvm.umin.* ’ Intrinsic ‘ llvm.scmp.* ’ Intrinsic ‘ llvm.ucmp.* ’ Intrinsic ‘ llvm.memcpy ’ Intrinsic ‘ llvm.memcpy.inline ’ Intrinsic ‘ llvm.memmove ’ Intrinsic ‘ llvm.memset.* ’ Intrinsics ‘ llvm.memset.inline ’ Intrinsic ‘ llvm.experimental.memset.pattern ’ Intrinsic ‘ llvm.sqrt.* ’ Intrinsic ‘ llvm.powi.* ’ Intrinsic ‘ llvm.sin.* ’ Intrinsic ‘ llvm.cos.* ’ Intrinsic ‘ llvm.tan.* ’ Intrinsic ‘ llvm.asin.* ’ Intrinsic ‘ llvm.acos.* ’ Intrinsic ‘ llvm.atan.* ’ Intrinsic ‘ llvm.atan2.* ’ Intrinsic ‘ llvm.sinh.* ’ Intrinsic ‘ llvm.cosh.* ’ Intrinsic ‘ llvm.tanh.* ’ Intrinsic ‘ llvm.sincos.* ’ Intrinsic ‘ llvm.sincospi.* ’ Intrinsic ‘ llvm.modf.* ’ Intrinsic ‘ llvm.pow.* ’ Intrinsic ‘ llvm.exp.* ’ Intrinsic ‘ llvm.exp2.* ’ Intrinsic ‘ llvm.exp10.* ’ Intrinsic ‘ llvm.ldexp.* ’ Intrinsic ‘ llvm.frexp.* ’ Intrinsic ‘ llvm.log.* ’ Intrinsic ‘ llvm.log10.* ’ Intrinsic ‘ llvm.log2.* ’ Intrinsic ‘ llvm.fma.* ’ Intrinsic ‘ llvm.fabs.* ’ Intrinsic ‘ llvm.min.* ’ Intrinsics Comparation ‘ llvm.minnum.* ’ Intrinsic ‘ llvm.maxnum.* ’ Intrinsic ‘ llvm.minimum.* ’ Intrinsic ‘ llvm.maximum.* ’ Intrinsic ‘ llvm.minimumnum.* ’ Intrinsic ‘ llvm.maximumnum.* ’ Intrinsic ‘ llvm.copysign.* ’ Intrinsic ‘ llvm.floor.* ’ Intrinsic ‘ llvm.ceil.* ’ Intrinsic ‘ llvm.trunc.* ’ Intrinsic ‘ llvm.rint.* ’ Intrinsic ‘ llvm.nearbyint.* ’ Intrinsic ‘ llvm.round.* ’ Intrinsic ‘ llvm.roundeven.* ’ Intrinsic ‘ llvm.lround.* ’ Intrinsic ‘ llvm.llround.* ’ Intrinsic ‘ llvm.lrint.* ’ Intrinsic ‘ llvm.llrint.* ’ Intrinsic Bit Manipulation Intrinsics ‘ llvm.bitreverse.* ’ Intrinsics ‘ llvm.bswap.* ’ Intrinsics ‘ llvm.ctpop.* ’ Intrinsic ‘ llvm.ctlz.* ’ Intrinsic ‘ llvm.cttz.* ’ Intrinsic ‘ llvm.fshl.* ’ Intrinsic ‘ llvm.fshr.* ’ Intrinsic ‘ llvm.clmul.* ’ Intrinsic Arithmetic with Overflow Intrinsics ‘ llvm.sadd.with.overflow.* ’ Intrinsics ‘ llvm.uadd.with.overflow.* ’ Intrinsics ‘ llvm.ssub.with.overflow.* ’ Intrinsics ‘ llvm.usub.with.overflow.* ’ Intrinsics ‘ llvm.smul.with.overflow.* ’ Intrinsics ‘ llvm.umul.with.overflow.* ’ Intrinsics Saturation Arithmetic Intrinsics ‘ llvm.sadd.sat.* ’ Intrinsics ‘ llvm.uadd.sat.* ’ Intrinsics ‘ llvm.ssub.sat.* ’ Intrinsics ‘ llvm.usub.sat.* ’ Intrinsics ‘ llvm.sshl.sat.* ’ Intrinsics ‘ llvm.ushl.sat.* ’ Intrinsics Fixed Point Arithmetic Intrinsics ‘ llvm.smul.fix.* ’ Intrinsics ‘ llvm.umul.fix.* ’ Intrinsics ‘ llvm.smul.fix.sat.* ’ Intrinsics ‘ llvm.umul.fix.sat.* ’ Intrinsics ‘ llvm.sdiv.fix.* ’ Intrinsics ‘ llvm.udiv.fix.* ’ Intrinsics ‘ llvm.sdiv.fix.sat.* ’ Intrinsics ‘ llvm.udiv.fix.sat.* ’ Intrinsics Specialized Arithmetic Intrinsics ‘ llvm.canonicalize.* ’ Intrinsic ‘ llvm.fmuladd.* ’ Intrinsic Hardware-Loop Intrinsics ‘ llvm.set.loop.iterations.* ’ Intrinsic ‘ llvm.start.loop.iterations.* ’ Intrinsic ‘ llvm.test.set.loop.iterations.* ’ Intrinsic ‘ llvm.test.start.loop.iterations.* ’ Intrinsic ‘ llvm.loop.decrement.reg.* ’ Intrinsic ‘ llvm.loop.decrement.* ’ Intrinsic Vector Reduction Intrinsics ‘ llvm.vector.reduce.add.* ’ Intrinsic ‘ llvm.vector.reduce.fadd.* ’ Intrinsic ‘ llvm.vector.reduce.mul.* ’ Intrinsic ‘ llvm.vector.reduce.fmul.* ’ Intrinsic ‘ llvm.vector.reduce.and.* ’ Intrinsic ‘ llvm.vector.reduce.or.* ’ Intrinsic ‘ llvm.vector.reduce.xor.* ’ Intrinsic ‘ llvm.vector.reduce.smax.* ’ Intrinsic ‘ llvm.vector.reduce.smin.* ’ Intrinsic ‘ llvm.vector.reduce.umax.* ’ Intrinsic ‘ llvm.vector.reduce.umin.* ’ Intrinsic ‘ llvm.vector.reduce.fmax.* ’ Intrinsic ‘ llvm.vector.reduce.fmin.* ’ Intrinsic ‘ llvm.vector.reduce.fmaximum.* ’ Intrinsic ‘ llvm.vector.reduce.fminimum.* ’ Intrinsic Vector Partial Reduction Intrinsics ‘ llvm.vector.partial.reduce.add.* ’ Intrinsic ‘ llvm.vector.partial.reduce.fadd.* ’ Intrinsic Vector Manipulation Intrinsics ‘ llvm.vector.insert ’ Intrinsic ‘ llvm.vector.extract ’ Intrinsic ‘ llvm.vector.reverse ’ Intrinsic ‘ llvm.vector.deinterleave2/3/4/5/6/7/8 ’ Intrinsic ‘ llvm.vector.interleave2/3/4/5/6/7/8 ’ Intrinsic ‘ llvm.vector.splice.left ’ Intrinsic ‘ llvm.vector.splice.right ’ Intrinsic ‘ llvm.stepvector ’ Intrinsic Experimental Vector Intrinsics ‘ llvm.experimental.cttz.elts ’ Intrinsic ‘ llvm.experimental.get.vector.length ’ Intrinsic ‘ llvm.experimental.vector.histogram.* ’ Intrinsic ‘ llvm.experimental.vector.extract.last.active ’ Intrinsic ‘ llvm.experimental.vector.compress.* ’ Intrinsics ‘ llvm.experimental.vector.match.* ’ Intrinsic Matrix Intrinsics ‘ llvm.matrix.transpose.* ’ Intrinsic ‘ llvm.matrix.multiply.* ’ Intrinsic ‘ llvm.matrix.column.major.load.* ’ Intrinsic ‘ llvm.matrix.column.major.store.* ’ Intrinsic Half Precision Floating-Point Intrinsics ‘ llvm.convert.to.fp16 ’ Intrinsic ‘ llvm.convert.from.fp16 ’ Intrinsic Saturating floating-point to integer conversions ‘ llvm.fptoui.sat.* ’ Intrinsic ‘ llvm.fptosi.sat.* ’ Intrinsic Floating-Point Conversion Intrinsics ‘ llvm.fptrunc.round ’ Intrinsic Convergence Intrinsics Debugger Intrinsics Exception Handling Intrinsics Pointer Authentication Intrinsics Trampoline Intrinsics ‘ llvm.init.trampoline ’ Intrinsic ‘ llvm.adjust.trampoline ’ Intrinsic Vector Predication Intrinsics Optimization Hint ‘ llvm.vp.select.* ’ Intrinsics ‘ llvm.vp.merge.* ’ Intrinsics ‘ llvm.vp.add.* ’ Intrinsics ‘ llvm.vp.sub.* ’ Intrinsics ‘ llvm.vp.mul.* ’ Intrinsics ‘ llvm.vp.sdiv.* ’ Intrinsics ‘ llvm.vp.udiv.* ’ Intrinsics ‘ llvm.vp.srem.* ’ Intrinsics ‘ llvm.vp.urem.* ’ Intrinsics ‘ llvm.vp.ashr.* ’ Intrinsics ‘ llvm.vp.lshr.* ’ Intrinsics ‘ llvm.vp.shl.* ’ Intrinsics ‘ llvm.vp.or.* ’ Intrinsics ‘ llvm.vp.and.* ’ Intrinsics ‘ llvm.vp.xor.* ’ Intrinsics ‘ llvm.vp.abs.* ’ Intrinsics ‘ llvm.vp.smax.* ’ Intrinsics ‘ llvm.vp.smin.* ’ Intrinsics ‘ llvm.vp.umax.* ’ Intrinsics ‘ llvm.vp.umin.* ’ Intrinsics ‘ llvm.vp.copysign.* ’ Intrinsics ‘ llvm.vp.minnum.* ’ Intrinsics ‘ llvm.vp.maxnum.* ’ Intrinsics ‘ llvm.vp.minimum.* ’ Intrinsics ‘ llvm.vp.maximum.* ’ Intrinsics ‘ llvm.vp.fadd.* ’ Intrinsics ‘ llvm.vp.fsub.* ’ Intrinsics ‘ llvm.vp.fmul.* ’ Intrinsics ‘ llvm.vp.fdiv.* ’ Intrinsics ‘ llvm.vp.frem.* ’ Intrinsics ‘ llvm.vp.fneg.* ’ Intrinsics ‘ llvm.vp.fabs.* ’ Intrinsics ‘ llvm.vp.sqrt.* ’ Intrinsics ‘ llvm.vp.fma.* ’ Intrinsics ‘ llvm.vp.fmuladd.* ’ Intrinsics ‘ llvm.vp.reduce.add.* ’ Intrinsics ‘ llvm.vp.reduce.fadd.* ’ Intrinsics ‘ llvm.vp.reduce.mul.* ’ Intrinsics ‘ llvm.vp.reduce.fmul.* ’ Intrinsics ‘ llvm.vp.reduce.and.* ’ Intrinsics ‘ llvm.vp.reduce.or.* ’ Intrinsics ‘ llvm.vp.reduce.xor.* ’ Intrinsics ‘ llvm.vp.reduce.smax.* ’ Intrinsics ‘ llvm.vp.reduce.smin.* ’ Intrinsics ‘ llvm.vp.reduce.umax.* ’ Intrinsics ‘ llvm.vp.reduce.umin.* ’ Intrinsics ‘ llvm.vp.reduce.fmax.* ’ Intrinsics ‘ llvm.vp.reduce.fmin.* ’ Intrinsics ‘ llvm.vp.reduce.fmaximum.* ’ Intrinsics ‘ llvm.vp.reduce.fminimum.* ’ Intrinsics ‘ llvm.get.active.lane.mask.* ’ Intrinsics ‘ llvm.loop.dependence.war.mask.* ’ Intrinsics ‘ llvm.loop.dependence.raw.mask.* ’ Intrinsics ‘ llvm.experimental.vp.splice ’ Intrinsic ‘ llvm.experimental.vp.reverse ’ Intrinsic ‘ llvm.vp.load ’ Intrinsic ‘ llvm.vp.load.ff ’ Intrinsic ‘ llvm.vp.store ’ Intrinsic ‘ llvm.experimental.vp.strided.load ’ Intrinsic ‘ llvm.experimental.vp.strided.store ’ Intrinsic ‘ llvm.vp.gather ’ Intrinsic ‘ llvm.vp.scatter ’ Intrinsic ‘ llvm.vp.trunc.* ’ Intrinsics ‘ llvm.vp.zext.* ’ Intrinsics ‘ llvm.vp.sext.* ’ Intrinsics ‘ llvm.vp.fptrunc.* ’ Intrinsics ‘ llvm.vp.fpext.* ’ Intrinsics ‘ llvm.vp.fptoui.* ’ Intrinsics ‘ llvm.vp.fptosi.* ’ Intrinsics ‘ llvm.vp.uitofp.* ’ Intrinsics ‘ llvm.vp.sitofp.* ’ Intrinsics ‘ llvm.vp.ptrtoint.* ’ Intrinsics ‘ llvm.vp.inttoptr.* ’ Intrinsics ‘ llvm.vp.fcmp.* ’ Intrinsics ‘ llvm.vp.icmp.* ’ Intrinsics ‘ llvm.vp.ceil.* ’ Intrinsics ‘ llvm.vp.floor.* ’ Intrinsics ‘ llvm.vp.rint.* ’ Intrinsics ‘ llvm.vp.nearbyint.* ’ Intrinsics ‘ llvm.vp.round.* ’ Intrinsics ‘ llvm.vp.roundeven.* ’ Intrinsics ‘ llvm.vp.roundtozero.* ’ Intrinsics ‘ llvm.vp.lrint.* ’ Intrinsics ‘ llvm.vp.llrint.* ’ Intrinsics ‘ llvm.vp.bitreverse.* ’ Intrinsics ‘ llvm.vp.bswap.* ’ Intrinsics ‘ llvm.vp.ctpop.* ’ Intrinsics ‘ llvm.vp.ctlz.* ’ Intrinsics ‘ llvm.vp.cttz.* ’ Intrinsics ‘ llvm.vp.cttz.elts.* ’ Intrinsics ‘ llvm.vp.sadd.sat.* ’ Intrinsics ‘ llvm.vp.uadd.sat.* ’ Intrinsics ‘ llvm.vp.ssub.sat.* ’ Intrinsics ‘ llvm.vp.usub.sat.* ’ Intrinsics ‘ llvm.vp.fshl.* ’ Intrinsics ‘ llvm.vp.fshr.* ’ Intrinsics ‘ llvm.vp.is.fpclass.* ’ Intrinsics Masked Vector Load and Store Intrinsics ‘ llvm.masked.load.* ’ Intrinsics ‘ llvm.masked.store.* ’ Intrinsics Masked Vector Gather and Scatter Intrinsics ‘ llvm.masked.gather.* ’ Intrinsics ‘ llvm.masked.scatter.* ’ Intrinsics Masked Vector Expanding Load and Compressing Store Intrinsics ‘ llvm.masked.expandload.* ’ Intrinsics ‘ llvm.masked.compressstore.* ’ Intrinsics Memory Use Markers ‘ llvm.lifetime.start ’ Intrinsic ‘ llvm.lifetime.end ’ Intrinsic ‘ llvm.invariant.start ’ Intrinsic ‘ llvm.invariant.end ’ Intrinsic ‘ llvm.launder.invariant.group ’ Intrinsic ‘ llvm.strip.invariant.group ’ Intrinsic Constrained Floating-Point Intrinsics ‘ llvm.experimental.constrained.fadd ’ Intrinsic ‘ llvm.experimental.constrained.fsub ’ Intrinsic ‘ llvm.experimental.constrained.fmul ’ Intrinsic ‘ llvm.experimental.constrained.fdiv ’ Intrinsic ‘ llvm.experimental.constrained.frem ’ Intrinsic ‘ llvm.experimental.constrained.fma ’ Intrinsic ‘ llvm.experimental.constrained.fptoui ’ Intrinsic ‘ llvm.experimental.constrained.fptosi ’ Intrinsic ‘ llvm.experimental.constrained.uitofp ’ Intrinsic ‘ llvm.experimental.constrained.sitofp ’ Intrinsic ‘ llvm.experimental.constrained.fptrunc ’ Intrinsic ‘ llvm.experimental.constrained.fpext ’ Intrinsic ‘ llvm.experimental.constrained.fcmp ’ and ‘ llvm.experimental.constrained.fcmps ’ Intrinsics ‘ llvm.experimental.constrained.fmuladd ’ Intrinsic Constrained libm-equivalent Intrinsics ‘ llvm.experimental.constrained.sqrt ’ Intrinsic ‘ llvm.experimental.constrained.pow ’ Intrinsic ‘ llvm.experimental.constrained.powi ’ Intrinsic ‘ llvm.experimental.constrained.ldexp ’ Intrinsic ‘ llvm.experimental.constrained.sin ’ Intrinsic ‘ llvm.experimental.constrained.cos ’ Intrinsic ‘ llvm.experimental.constrained.tan ’ Intrinsic ‘ llvm.experimental.constrained.asin ’ Intrinsic ‘ llvm.experimental.constrained.acos ’ Intrinsic ‘ llvm.experimental.constrained.atan ’ Intrinsic ‘ llvm.experimental.constrained.atan2 ’ Intrinsic ‘ llvm.experimental.constrained.sinh ’ Intrinsic ‘ llvm.experimental.constrained.cosh ’ Intrinsic ‘ llvm.experimental.constrained.tanh ’ Intrinsic ‘ llvm.experimental.constrained.exp ’ Intrinsic ‘ llvm.experimental.constrained.exp2 ’ Intrinsic ‘ llvm.experimental.constrained.log ’ Intrinsic ‘ llvm.experimental.constrained.log10 ’ Intrinsic ‘ llvm.experimental.constrained.log2 ’ Intrinsic ‘ llvm.experimental.constrained.rint ’ Intrinsic ‘ llvm.experimental.constrained.lrint ’ Intrinsic ‘ llvm.experimental.constrained.llrint ’ Intrinsic ‘ llvm.experimental.constrained.nearbyint ’ Intrinsic ‘ llvm.experimental.constrained.maxnum ’ Intrinsic ‘ llvm.experimental.constrained.minnum ’ Intrinsic ‘ llvm.experimental.constrained.maximum ’ Intrinsic ‘ llvm.experimental.constrained.minimum ’ Intrinsic ‘ llvm.experimental.constrained.ceil ’ Intrinsic ‘ llvm.experimental.constrained.floor ’ Intrinsic ‘ llvm.experimental.constrained.round ’ Intrinsic ‘ llvm.experimental.constrained.roundeven ’ Intrinsic ‘ llvm.experimental.constrained.lround ’ Intrinsic ‘ llvm.experimental.constrained.llround ’ Intrinsic ‘ llvm.experimental.constrained.trunc ’ Intrinsic ‘ llvm.experimental.noalias.scope.decl ’ Intrinsic Floating Point Environment Manipulation intrinsics ‘ llvm.get.rounding ’ Intrinsic ‘ llvm.set.rounding ’ Intrinsic ‘ llvm.get.fpenv ’ Intrinsic ‘ llvm.set.fpenv ’ Intrinsic ‘ llvm.reset.fpenv ’ Intrinsic ‘ llvm.get.fpmode ’ Intrinsic ‘ llvm.set.fpmode ’ Intrinsic ‘ llvm.reset.fpmode ’ Intrinsic Floating-Point Test Intrinsics ‘ llvm.is.fpclass ’ Intrinsic General Intrinsics ‘ llvm.var.annotation ’ Intrinsic ‘ llvm.ptr.annotation.* ’ Intrinsic ‘ llvm.annotation.* ’ Intrinsic ‘ llvm.codeview.annotation ’ Intrinsic ‘ llvm.trap ’ Intrinsic ‘ llvm.debugtrap ’ Intrinsic ‘ llvm.ubsantrap ’ Intrinsic ‘ llvm.stackprotector ’ Intrinsic ‘ llvm.stackguard ’ Intrinsic ‘ llvm.objectsize ’ Intrinsic ‘ llvm.expect ’ Intrinsic ‘ llvm.expect.with.probability ’ Intrinsic ‘ llvm.assume ’ Intrinsic ‘ llvm.ssa.copy ’ Intrinsic ‘ llvm.type.test ’ Intrinsic ‘ llvm.type.checked.load ’ Intrinsic ‘ llvm.type.checked.load.relative ’ Intrinsic ‘ llvm.arithmetic.fence ’ Intrinsic ‘ llvm.donothing ’ Intrinsic ‘ llvm.experimental.deoptimize ’ Intrinsic ‘ llvm.experimental.guard ’ Intrinsic ‘ llvm.experimental.widenable.condition ’ Intrinsic ‘ llvm.allow.ubsan.check ’ Intrinsic ‘ llvm.allow.runtime.check ’ Intrinsic ‘ llvm.load.relative ’ Intrinsic ‘ llvm.sideeffect ’ Intrinsic ‘ llvm.is.constant.* ’ Intrinsic ‘ llvm.ptrmask ’ Intrinsic ‘ llvm.threadlocal.address ’ Intrinsic ‘ llvm.vscale ’ Intrinsic ‘ llvm.fake.use ’ Intrinsic ‘ llvm.reloc.none ’ Intrinsic Stack Map Intrinsics Element Wise Atomic Memory Intrinsics ‘ llvm.memcpy.element.unordered.atomic ’ Intrinsic ‘ llvm.memmove.element.unordered.atomic ’ Intrinsic ‘ llvm.memset.element.unordered.atomic ’ Intrinsic Objective-C ARC Runtime Intrinsics ‘ llvm.objc.autorelease ’ Intrinsic ‘ llvm.objc.autoreleasePoolPop ’ Intrinsic ‘ llvm.objc.autoreleasePoolPush ’ Intrinsic ‘ llvm.objc.autoreleaseReturnValue ’ Intrinsic ‘ llvm.objc.copyWeak ’ Intrinsic ‘ llvm.objc.destroyWeak ’ Intrinsic ‘ llvm.objc.initWeak ’ Intrinsic ‘ llvm.objc.loadWeak ’ Intrinsic ‘ llvm.objc.loadWeakRetained ’ Intrinsic ‘ llvm.objc.moveWeak ’ Intrinsic ‘ llvm.objc.release ’ Intrinsic ‘ llvm.objc.retain ’ Intrinsic ‘ llvm.objc.retainAutorelease ’ Intrinsic ‘ llvm.objc.retainAutoreleaseReturnValue ’ Intrinsic ‘ llvm.objc.retainAutoreleasedReturnValue ’ Intrinsic ‘ llvm.objc.retainBlock ’ Intrinsic ‘ llvm.objc.storeStrong ’ Intrinsic ‘ llvm.objc.storeWeak ’ Intrinsic Preserving Debug Information Intrinsics ‘ llvm.preserve.array.access.index ’ Intrinsic ‘ llvm.preserve.union.access.index ’ Intrinsic ‘ llvm.preserve.struct.access.index ’ Intrinsic ‘ llvm.protected.field.ptr ’ Intrinsic Abstract ¶ This document is a reference manual for the LLVM assembly language. LLVM is a Static Single Assignment (SSA) based representation that provides type safety, low-level operations, flexibility, and the capability of representing ‘all’ high-level languages cleanly. It is the common code representation used throughout all phases of the LLVM compilation strategy. Introduction ¶ The LLVM code representation is designed to be used in three different forms: as an in-memory compiler IR, as an on-disk bitcode representation (suitable for fast loading by a Just-In-Time compiler), and as a human readable assembly language representation. This allows LLVM to provide a powerful intermediate representation for efficient compiler transformations and analysis, while providing a natural means to debug and visualize the transformations. The three different forms of LLVM are all equivalent. This document describes the human-readable representation and notation. The LLVM representation aims to be light-weight and low-level while being expressive, typed, and extensible at the same time. It aims to be a “universal IR” of sorts, by being at a low enough level that high-level ideas may be cleanly mapped to it (similar to how microprocessors are “universal IR’s”, allowing many source languages to be mapped to them). By providing type information, LLVM can be used as the target of optimizations: for example, through pointer analysis, it can be proven that a C automatic variable is never accessed outside of the current function, allowing it to be promoted to a simple SSA value instead of a memory location. Well-Formedness ¶ It is important to note that this document describes ‘well formed’ LLVM assembly language. There is a difference between what the parser accepts and what is considered ‘well formed’. For example, the following instruction is syntactically okay, but not well formed: %x = add i32 1 , %x because the definition of %x does not dominate all of its uses. The LLVM infrastructure provides a verification pass that may be used to verify that an LLVM module is well formed. This pass is automatically run by the parser after parsing input assembly and by the optimizer before it outputs bitcode. The violations pointed out by the verifier pass indicate bugs in transformation passes or input to the parser. Syntax ¶ Identifiers ¶ LLVM identifiers come in two basic types: global and local. Global identifiers (functions, global variables) begin with the '@' character. Local identifiers (register names, types) begin with the '%' character. Additionally, there are three different formats for identifiers, for different purposes: Named values are represented as a string of characters with their prefix. For example, %foo , @DivisionByZero , %a.really.long.identifier . The actual regular expression used is ‘ [%@][-a-zA-Z$._][-a-zA-Z$._0-9]* ’. Identifiers that require other characters in their names can be surrounded with quotes. Special characters may be escaped using "\xx" where xx is the ASCII code for the character in hexadecimal. In this way, any character can be used in a name value, even quotes themselves. The "\01" prefix can be used on global values to suppress mangling. Unnamed values are represented as an unsigned numeric value with their prefix. For example, %12 , @2 , %44 . Constants, which are described in the section Constants below. LLVM requires that values start with a prefix for two reasons: Compilers don’t need to worry about name clashes with reserved words, and the set of reserved words may be expanded in the future without penalty. Additionally, unnamed identifiers allow a compiler to quickly come up with a temporary variable without having to avoid symbol table conflicts. Reserved words in LLVM are very similar to reserved words in other languages. There are keywords for different opcodes (’ add ’, ‘ bitcast ’, ‘ ret ’, etc…), for primitive type names (’ void ’, ‘ i32 ’, etc…), and others. These reserved words cannot conflict with variable names, because none of them start with a prefix character ( '%' or '@' ). Here is an example of LLVM code to multiply the integer variable ‘ %X ’ by 8: The easy way: %result = mul i32 %X , 8 After strength reduction: %result = shl i32 %X , 3 And the hard way: %0 = add i32 %X , %X ; yields i32:%0 %1 = add i32 %0 , %0 / * yields i32: %1 * / %result = add i32 %1 , %1 This last way of multiplying %X by 8 illustrates several important lexical features of LLVM: Comments are delimited with a ‘ ; ’ and go until the end of line. Alternatively, comments can start with /* and terminate with */ . Unnamed temporaries are created when the result of a computation is not assigned to a named value. By default, unnamed temporaries are numbered sequentially (using a per-function incrementing counter, starting with 0). However, when explicitly specifying temporary numbers, it is allowed to skip over numbers. Note that basic blocks and unnamed function parameters are included in this numbering. For example, if the entry basic block is not given a label name and all function parameters are named, then it will get number 0. It also shows a convention that we follow in this document. When demonstrating instructions, we will follow an instruction with a comment that defines the type and name of value produced. String constants ¶ Strings in LLVM programs are delimited by " characters. Within a string, all bytes are treated literally with the exception of \ characters, which start escapes, and the first " character, which ends the string. There are two kinds of escapes. \\ represents a single \ character. \ followed by two hexadecimal characters (0-9, a-f, or A-F) represents the byte with the given value (e.g., \00 represents a null byte). To represent a " character, use \22 . ( \" will end the string with a trailing \ .) Newlines do not terminate string constants; strings can span multiple lines. The interpretation of string constants (e.g., their character encoding) depends on context. High Level Structure ¶ Module Structure ¶ LLVM programs are composed of Module ’s, each of which is a translation unit of the input programs. Each module consists of functions, global variables, and symbol table entries. Modules may be combined together with the LLVM linker, which merges function (and global variable) definitions, resolves forward declarations, and merges symbol table entries. Here is an example of the “hello world” module: ; Declare the string constant as a global constant. @.str = private unnamed_addr constant [ 13 x i8 ] c "hello world\0A\00" ; External declaration of the puts function declare i32 @puts ( ptr captures ( none )) nounwind ; Definition of main function define i32 @main () { ; Call puts function to write out the string to stdout. call i32 @puts ( ptr @.str ) ret i32 0 } ; Named metadata !0 = !{ i32 42 , null , !"string" } !foo = !{ !0 } This example is made up of a global variable named “ .str ”, an external declaration of the “ puts ” function, a function definition for “ main ” and named metadata “ foo ”. In general, a module is made up of a list of global values (where both functions and global variables are global values). Global values are represented by a pointer to a memory location (in this case, a pointer to an array of char, and a pointer to a function), and have one of the following linkage types . Linkage Types ¶ All Global Variables and Functions have one of the following types of linkage: private Global values with “ private ” linkage are only directly accessible by objects in the current module. In particular, linking code into a module with a private global value may cause the private to be renamed as necessary to avoid collisions. Because the symbol is private to the module, all references can be updated. This doesn’t show up in any symbol table in the object file. internal Similar to private, but the value shows as a local symbol ( STB_LOCAL in the case of ELF) in the object file. This corresponds to the notion of the ‘ static ’ keyword in C. available_externally Globals with “ available_externally ” linkage are never emitted into the object file corresponding to the LLVM module. From the linker’s perspective, an available_externally global is equivalent to an external declaration. They exist to allow inlining and other optimizations to take place given knowledge of the definition of the global, which is known to be somewhere outside the module. Globals with available_externally linkage are allowed to be discarded at will, and allow inlining and other optimizations. This linkage type is only allowed on definitions, not declarations. linkonce Globals with “ linkonce ” linkage are merged with other globals of the same name when linkage occurs. This can be used to implement some forms of inline functions, templates, or other code which must be generated in each translation unit that uses it, but where the body may be overridden with a more definitive definition later. Unreferenced linkonce globals are allowed to be discarded. Note that linkonce linkage does not actually allow the optimizer to inline the body of this function into callers because it doesn’t know if this definition of the function is the definitive definition within the program or whether it will be overridden by a stronger definition. To enable inlining and other optimizations, use “ linkonce_odr ” linkage. weak “ weak ” linkage has the same merging semantics as linkonce linkage, except that unreferenced globals with weak linkage may not be discarded. This is used for globals that are declared “weak” in C source code. common “ common ” linkage is most similar to “ weak ” linkage, but they are used for tentative definitions in C, such as “ int X; ” at global scope. Symbols with “ common ” linkage are merged in the same way as weak symbols , and they may not be deleted if unreferenced. common symbols may not have an explicit section, must have a zero initializer, and may not be marked ‘ constant ’. Functions and aliases may not have common linkage. appending “ appending ” linkage may only be applied to global variables of pointer to array type. When two global variables with appending linkage are linked together, the two global arrays are appended together. This is the LLVM, typesafe, equivalent of having the system linker append together “sections” with identical names when .o files are linked. Unfortunately this doesn’t correspond to any feature in .o files, so it can only be used for variables like llvm.global_ctors which llvm interprets specially. extern_weak The semantics of this linkage follow the ELF object file model: the symbol is weak until linked, if not linked, the symbol becomes null instead of being an undefined reference. linkonce_odr , weak_odr The odr suffix indicates that all globals defined with the given name are equivalent, along the lines of the C++ “one definition rule” (“ODR”). Informally, this means we can inline functions and fold loads of constants. Formally, use the following definition: when an odr function is called, one of the definitions is non-deterministically chosen to run. For odr variables, if any byte in the value is not equal in all initializers, that byte is a poison value . For aliases and ifuncs, apply the rule for the underlying function or variable. These linkage types are otherwise the same as their non- odr versions. external If none of the above identifiers are used, the global is externally visible, meaning that it participates in linkage and can be used to resolve external symbol references. It is illegal for a global variable or function declaration to have any linkage type other than external or extern_weak . Calling Conventions ¶ LLVM functions , calls and invokes can all have an optional calling convention specified for the call. The calling convention of any pair of dynamic caller/callee must match, or the behavior of the program is undefined. The following calling conventions are supported by LLVM, and more may be added in the future: “ ccc ” - The C calling convention This calling convention (the default if no other calling convention is specified) matches the target C calling conventions. This calling convention supports varargs function calls and tolerates some mismatch in the declared prototype and implemented declaration of the function (as does normal C). “ fastcc ” - The fast calling convention This calling convention attempts to make calls as fast as possible (e.g., by passing things in registers). This calling convention allows the target to use whatever tricks it wants to produce fast code for the target, without having to conform to an externally specified ABI (Application Binary Interface). Targets may use different implementations according to different features. In this case, a TTI interface useFastCCForInternalCall must return false when any caller functions and the callee belong to different implementations. Tail calls can only be optimized when this, the tailcc, the GHC or the HiPE convention is used. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition. “ coldcc ” - The cold calling convention This calling convention attempts to make code in the caller as efficient as possible under the assumption that the call is not commonly executed. As such, these calls often preserve all registers so that the call does not break any live ranges in the caller side. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition. Furthermore the inliner doesn’t consider such function calls for inlining. “ ghccc ” - GHC convention This calling convention has been implemented specifically for use by the Glasgow Haskell Compiler (GHC) . It passes everything in registers, going to extremes to achieve this by disabling callee save registers. This calling convention should not be used lightly but only for specific situations such as an alternative to the register pinning performance technique often used when implementing functional programming languages. At the moment only X86, AArch64, and RISCV support this convention. The following limitations exist: On X86-32 only up to 4 bit type parameters are supported. No floating-point types are supported. On X86-64 only up to 10 bit type parameters and 6 floating-point parameters are supported. On AArch64 only up to 4 32-bit floating-point parameters, 4 64-bit floating-point parameters, and 10 bit type parameters are supported. RISCV64 only supports up to 11 bit type parameters, 4 32-bit floating-point parameters, and 4 64-bit floating-point parameters. This calling convention supports tail call optimization but requires both the caller and callee to use it. “ cc 11 ” - The HiPE calling convention This calling convention has been implemented specifically for use by the High-Performance Erlang (HiPE) compiler, the native code compiler of the Ericsson’s Open Source Erlang/OTP system . It uses more registers for argument passing than the ordinary C calling convention and defines no callee-saved registers. The calling convention properly supports tail call optimization but requires that both the caller and the callee use it. It uses a register pinning mechanism, similar to GHC’s convention, for keeping frequently accessed runtime components pinned to specific hardware registers. At the moment only X86 supports this convention (both 32 and 64 bit). “ anyregcc ” - Dynamic calling convention for code patching This is a special convention that supports patching an arbitrary code sequence in place of a call site. This convention forces the call arguments into registers but allows them to be dynamically allocated. This can currently only be used with calls to llvm.experimental.patchpoint because only this intrinsic records the location of its arguments in a side table. See Stack maps and patch points in LLVM . “ preserve_mostcc ” - The PreserveMost calling convention This calling convention attempts to make the code in the caller as unintrusive as possible. This convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This alleviates the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn’t apply for values returned in callee-saved registers. On X86-64 the callee preserves all general purpose registers, except for R11 and return registers, if any. R11 can be used as a scratch register. The treatment of floating-point registers (XMMs/YMMs) matches the OS’s C calling convention: on most platforms, they are not preserved and need to be saved by the caller, but on Windows, xmm6-xmm15 are preserved. On AArch64 the callee preserves all general purpose registers, except X0-X8 and X16-X18. Not allowed with nest . On RISC-V the callee preserves x5-x31 except x6, x7 and x28 registers. On LoongArch the callee preserves r4-r31 except r12-r15 and r20-r21 registers. The idea behind this convention is to support calls to runtime functions that have a hot path and a cold path. The hot path is usually a small piece of code that doesn’t use many registers. The cold path might need to call out to another function and therefore only needs to preserve the caller-saved registers, which haven’t already been saved by the caller. The PreserveMost calling convention is very similar to the cold calling convention in terms of caller/callee-saved registers, but they are used for different types of function calls. coldcc is for function calls that are rarely executed, whereas preserve_mostcc function calls are intended to be on the hot path and definitely executed a lot. Furthermore preserve_mostcc doesn’t prevent the inliner from inlining the function call. This calling convention will be used by a future version of the Objective-C runtime and should therefore still be considered experimental at this time. Although this convention was created to optimize certain runtime calls to the Objective-C runtime, it is not limited to this runtime and might be used by other runtimes in the future too. The current implementation only supports X86-64, but the intention is to support more architectures in the future. “ preserve_allcc ” - The PreserveAll calling convention This calling convention attempts to make the code in the caller even less intrusive than the PreserveMost calling convention. This calling convention also behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. This removes the burden of saving and recovering a large register set before and after the call in the caller. If the arguments are passed in callee-saved registers, then they will be preserved by the callee across the call. This doesn’t apply for values returned in callee-saved registers. On X86-64 the callee preserves all general purpose registers, except for R11. R11 can be used as a scratch register. Furthermore it also preserves all floating-point registers (XMMs/YMMs). On AArch64 the callee preserves all general purpose registers, except X0-X8 and X16-X18. Furthermore it also preserves lower 128 bits of V8-V31 SIMD floating point registers. Not allowed with nest . The idea behind this convention is to support calls to runtime functions that don’t need to call out to any other functions. This calling convention, like the PreserveMost calling convention, will be used by a future version of the Objective-C runtime and should be considered experimental at this time. “ preserve_nonecc ” - The PreserveNone calling convention This calling convention doesn’t preserve any general registers. So all general registers are caller saved registers. It also uses all general registers to pass arguments. This attribute doesn’t impact non-general purpose registers (e.g., floating point registers, on X86 XMMs/YMMs). Non-general purpose registers still follow the standard C calling convention. Currently it is for x86_64 and AArch64 only. “ cxx_fast_tlscc ” - The CXX_FAST_TLS calling convention for access functions Clang generates an access function to access C++-style Thread Local Storage (TLS). The access function generally has an entry block, an exit block and an initialization block that is run at the first time. The entry and exit blocks can access a few TLS IR variables, each access will be lowered to a platform-specific sequence. This calling convention aims to minimize overhead in the caller by preserving as many registers as possible (all the registers that are preserved on the fast path, composed of the entry and exit blocks). This calling convention behaves identically to the C calling convention on how arguments and return values are passed, but it uses a different set of caller/callee-saved registers. Given that each platform has its own lowering sequence, hence its own set of preserved registers, we can’t use the existing PreserveMost . On X86-64 the callee preserves all general purpose registers, except for RDI and RAX. “ tailcc ” - Tail callable calling convention This calling convention ensures that calls in tail position will always be tail call optimized. This calling convention is equivalent to fastcc, except for an additional guarantee that tail calls will be produced whenever possible. Tail calls can only be optimized when this, the fastcc, the GHC or the HiPE convention is used. This calling convention does not support varargs and requires the prototype of all callees to exactly match the prototype of the function definition. “ swiftcc ” - This calling convention is used for Swift language. On X86-64 RCX and R8 are available for additional integer returns, and XMM2 and XMM3 are available for additional FP/vector returns. On iOS platforms, we use AAPCS-VFP calling convention. “ swifttailcc ” This calling convention is like swiftcc in most respects, but also the callee pops the argument area of the stack so that mandatory tail calls are possible as in tailcc . “ cfguard_checkcc ” - Windows Control Flow Guard (Check mechanism) This calling convention is used for the Control Flow Guard check function, calls to which can be inserted before indirect calls to check that the call target is a valid function address. The check function has no return value, but it will trigger an OS-level error if the address is not a valid target. The set of registers preserved by the check function, and the register containing the target address are architecture-specific. On X86 the target address is passed in ECX. On ARM the target address is passed in R0. On AArch64 the target address is passed in X15. “ cc <n> ” - Numbered convention Any calling convention may be specified by number, allowing target-specific calling conventions to be used. Target-specific calling conventions start at 64. More calling conventions can be added/defined on an as-needed basis, to support Pascal conventions or any other well-known target-independent convention. Visibility Styles ¶ All Global Variables and Functions have one of the following visibility styles: “ default ” - Default style On targets that use the ELF object file format, default visibility means that the declaration is visible to other modules and, in shared libraries, means that the declared entity may be overridden. On Darwin, default visibility means that the declaration is visible to other modules. On XCOFF, default visibility means no explicit visibility bit will be set and whether the symbol is visible (i.e “exported”) to other modules depends primarily on export lists provided to the linker. Default visibility corresponds to “external linkage” in the language. “ hidden ” - Hidd	2026-01-13T08:49:47
https://docs.suprsend.com/docs/getting-started#content-area	What is SuprSend? - SuprSend, Notification infrastructure for Product teams Skip to main content SuprSend, Notification infrastructure for Product teams home page Search... ⌘ K Community Trust Center Platform Status Postman Collection GETTING STARTED What is SuprSend? Quick Start Guide Best Practices Plan Your Integration Go-live checklist CORE CONCEPTS Templates Users Events Workflow Notification Categories Preferences Tenants Lists Broadcast Objects Translations DLT Guidelines Whatsapp Template Guidelines WORKFLOW BUILDER Design Workflow Node List Workflow Settings Trigger Workflow Validate Trigger Payload Tenant Workflows Notification Inbox Overview Multi Tabs React Javascript (Angular, Vuejs etc) React Native Flutter (Headless) PREFERENCE CENTRE Embedded Preference Centre Javascript Angular React VENDOR INTEGRATION GUIDE Overview Email Integrations SMS Integrations Android Push Whatsapp Integrations iOS Push Chat Integrations Vendor Fallback Tenant Vendor INTEGRATIONS Webhook Connectors MONITORING & DEBUGGING Logs Audit Logs Error Guides MANAGE YOUR ACCOUNT Authentication Methods Contact Us Get Started SuprSend, Notification infrastructure for Product teams home page Search... ⌘ K Ask AI Contact Us Get Started Get Started Search... Navigation GETTING STARTED What is SuprSend? Documentation API Reference Management API CLI Reference Developer Resources Changelog Documentation API Reference Management API CLI Reference Developer Resources Changelog GETTING STARTED What is SuprSend? OpenAI Open in ChatGPT Learn about SuprSend and how you can use it to power multi-channel product notifications. OpenAI Open in ChatGPT SuprSend has all the features set which enable you to send notifications in a reliable and scalable manner, as well as take care of end-user experience, thereby eliminating the need to build any notification service in-house. Benefits of using SuprSend as your notification stack: You do not have to do any vendor integrations for channels in your code. You can easily add/remove/prioritise vendors and channels from your SuprSend account, You can design powerful templates for all channels together and manage them from a single place, You can leverage powerful features to experiment fast with notifications as well as take care of end user experience without writing a single line of code. Introduction to Workflows Communications are made up of multiple components - trigger, logic, content, variables, target user, channels, vendors, etc. Typical communication solutions have one or more components intertwined with each other. SuprSend solves communications from a different and more powerful approach, which we call Workflows. At SuprSend, all the constituent components are decoupled from each other, making it modular in nature. The components can come from any source. All these components are configured as nodes in Workflows, where the processing happens for delivery and optimisation. This allows Workflows to handle any complexity possible in your communication use cases. How do you trigger notifications? You can trigger notifications in one of the two ways: Send events to SuprSend from your frontend clients (android app, website, etc) via SuprSend Client SDK, and create a Workflow on SuprSend platform to trigger notification on an event. Create workflow and trigger notification from your backend itself using an omni-channel HTTPS API method, or you can use our Backend SDK. All the other components (like vendors, templates, optimisation, scaling, etc.) are created and managed on SuprSend platform. You can check the ‘Core Concepts’ section that lists down the components used in the platform, so you can navigate the platform and use all the features with ease. SuprSend APIs You can try out SuprSend APIs from our Postman collection Was this page helpful? Yes No Suggest edits Raise issue Overview Start setting up your notifications with SuprSend by following quick start guides for one of the mentioned channels. Next ⌘ I x github linkedin youtube Powered by On this page Benefits of using SuprSend as your notification stack: Introduction to Workflows How do you trigger notifications? SuprSend APIs	2026-01-13T08:49:47
https://opensource.org/license/cern-ohl-p	CERN Open Hardware Licence Version 2 – Permissive – Open Source Initiative Skip to content Get involved About Licenses Open Source Definition Open Source AI Programs Blog Get involved About Licenses Open Source Definition Open Source AI Programs Blog Open Main Menu Special Purpose CERN Open Hardware Licence Version 2 – Permissive Version 2 Submitted: June 29, 2020 Submitter: Andrew Katz Approved: January 15, 2021 Board minutes SPDX short identifier: CERN-OHL-P-2.0 Steward: CERN Link to license steward's version Preamble CERN has developed this licence to promote collaboration among hardware designers and to provide a legal tool which supports the freedom to use, study, modify, share and distribute hardware designs and products based on those designs. Version 2 of the CERN Open Hardware Licence comes in three variants: this licence, CERN-OHL-P (permissive); and two reciprocal licences: CERN-OHL-W (weakly reciprocal) and CERN-OHL-S (strongly reciprocal). The CERN-OHL-P is copyright CERN 2020. Anyone is welcome to use it, in unmodified form only. Use of this Licence does not imply any endorsement by CERN of any Licensor or their designs nor does it imply any involvement by CERN in their development. 1 Definitions 1.1 ‘Licence’ means this CERN-OHL-P. 1.2 ‘Source’ means information such as design materials or digital code which can be applied to Make or test a Product or to prepare a Product for use, Conveyance or sale, regardless of its medium or how it is expressed. It may include Notices. 1.3 ‘Covered Source’ means Source that is explicitly made available under this Licence. 1.4 ‘Product’ means any device, component, work or physical object, whether in finished or intermediate form, arising from the use, application or processing of Covered Source. 1.5 ‘Make’ means to create or configure something, whether by manufacture, assembly, compiling, loading or applying Covered Source or another Product or otherwise. 1.6 ‘Notice’ means copyright, acknowledgement and trademark notices, references to the location of any Notices, modification notices (subsection 3.3(b)) and all notices that refer to this Licence and to the disclaimer of warranties that are included in the Covered Source. 1.7 ‘Licensee’ or ‘You’ means any person exercising rights under this Licence. 1.8 ‘Licensor’ means a person who creates Source or modifies Covered Source and subsequently Conveys the resulting Covered Source under the terms and conditions of this Licence. A person may be a Licensee and a Licensor at the same time. 1.9 ‘Convey’ means to communicate to the public or distribute. 2 Applicability 2.1 This Licence governs the use, copying, modification, Conveying of Covered Source and Products, and the Making of Products. By exercising any right granted under this Licence, You irrevocably accept these terms and conditions. 2.2 This Licence is granted by the Licensor directly to You, and shall apply worldwide and without limitation in time. 2.3 You shall not attempt to restrict by contract or otherwise the rights granted under this Licence to other Licensees. 2.4 This Licence is not intended to restrict fair use, fair dealing, or any other similar right. 3 Copying, Modifying and Conveying Covered Source 3.1 You may copy and Convey verbatim copies of Covered Source, in any medium, provided You retain all Notices. 3.2 You may modify Covered Source, other than Notices. You may only delete Notices if they are no longer applicable to the corresponding Covered Source as modified by You and You may add additional Notices applicable to Your modifications. 3.3 You may Convey modified Covered Source (with the effect that You shall also become a Licensor) provided that You: a) retain Notices as required in subsection 3.2; and b) add a Notice to the modified Covered Source stating that You have modified it, with the date and brief description of how You have modified it. 3.4 You may Convey Covered Source or modified Covered Source under licence terms which differ from the terms of this Licence provided that You: a) comply at all times with subsection 3.3; and b) provide a copy of this Licence to anyone to whom You Convey Covered Source or modified Covered Source. 4 Making and Conveying Products You may Make Products, and/or Convey them, provided that You ensure that the recipient of the Product has access to any Notices applicable to the Product. 5 DISCLAIMER AND LIABILITY 5.1 DISCLAIMER OF WARRANTY — The Covered Source and any Products are provided ‘as is’ and any express or implied warranties, including, but not limited to, implied warranties of merchantability, of satisfactory quality, non-infringement of third party rights, and fitness for a particular purpose or use are disclaimed in respect of any Source or Product to the maximum extent permitted by law. The Licensor makes no representation that any Source or Product does not or will not infringe any patent, copyright, trade secret or other proprietary right. The entire risk as to the use, quality, and performance of any Source or Product shall be with You and not the Licensor. This disclaimer of warranty is an essential part of this Licence and a condition for the grant of any rights granted under this Licence. 5.2 EXCLUSION AND LIMITATION OF LIABILITY — The Licensor shall, to the maximum extent permitted by law, have no liability for direct, indirect, special, incidental, consequential, exemplary, punitive or other damages of any character including, without limitation, procurement of substitute goods or services, loss of use, data or profits, or business interruption, however caused and on any theory of contract, warranty, tort (including negligence), product liability or otherwise, arising in any way in relation to the Covered Source, modified Covered Source and/or the Making or Conveyance of a Product, even if advised of the possibility of such damages, and You shall hold the Licensor(s) free and harmless from any liability, costs, damages, fees and expenses, including claims by third parties, in relation to such use. 6 Patents 6.1 Subject to the terms and conditions of this Licence, each Licensor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section 6, or where terminated by the Licensor for cause) patent licence to Make, have Made, use, offer to sell, sell, import, and otherwise transfer the Covered Source and Products, where such licence applies only to those patent claims licensable by such Licensor that are necessarily infringed by exercising rights under the Covered Source as Conveyed by that Licensor. 6.2 If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Covered Source or a Product constitutes direct or contributory patent infringement, or You seek any declaration that a patent licensed to You under this Licence is invalid or unenforceable then any rights granted to You under this Licence shall terminate as of the date such process is initiated. 7 General 7.1 If any provisions of this Licence are or subsequently become invalid or unenforceable for any reason, the remaining provisions shall remain effective. 7.2 You shall not use any of the name (including acronyms and abbreviations), image, or logo by which the Licensor or CERN is known, except where needed to comply with section 3, or where the use is otherwise allowed by law. Any such permitted use shall be factual and shall not be made so as to suggest any kind of endorsement or implication of involvement by the Licensor or its personnel. 7.3 CERN may publish updated versions and variants of this Licence which it considers to be in the spirit of this version, but may differ in detail to address new problems or concerns. New versions will be published with a unique version number and a variant identifier specifying the variant. If the Licensor has specified that a given variant applies to the Covered Source without specifying a version, You may treat that Covered Source as being released under any version of the CERN-OHL with that variant. If no variant is specified, the Covered Source shall be treated as being released under CERN-OHL-S. The Licensor may also specify that the Covered Source is subject to a specific version of the CERN-OHL or any later version in which case You may apply this or any later version of CERN-OHL with the same variant identifier published by CERN. 7.4 This Licence shall not be enforceable except by a Licensor acting as such, and third party beneficiary rights are specifically excluded. Donate to the OSI The OSI is the authority that defines Open Source, recognized globally by individuals, companies, and public institutions. The Open Source Initiative (OSI) is a 501(c)3 public benefit corporation, founded in 1998. --> Get involved Mastodon Twitter LinkedIn Reddit About About Our team Board of directors Sponsors Programs Blog Press mentions Trademark Bylaws Licenses Open Source Definition Licenses License Review Process Open Standards Requirement for Software Open Source AI Open Source AI OSAI Definition Process Timeline Open Weights FAQ Checklist Forum Community Become an Individual Member Become an OSI Affiliate Affiliate Organizations Maintainers Events Forum OpenSource.net The content on this website, of which Opensource.org is the author, is licensed under a Creative Commons Attribution 4.0 International License . Opensource.org is not the author of any of the licenses reproduced on this site. Questions about the copyright in a license should be directed to the license steward. Read our Privacy Policy Proudly powered by WordPress. Hosted by Pressable. Manage Cookie Consent To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions. Functional Functional Always active The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network. Preferences Preferences The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user. Statistics Statistics The technical storage or access that is used exclusively for statistical purposes. The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you. Marketing Marketing The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes. Manage options Manage services Manage {vendor_count} vendors Read more about these purposes Accept Deny View preferences Save preferences View preferences {title} {title} {title} Manage consent	2026-01-13T08:49:47
http://llvm-compile-time-tracker.com/	LLVM Compile-Time Tracker Index \| Graphs \| Compare \| About Config: Overview stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g Metric: instructions instructions:u max-rss task-clock cycles branches branch-misses wall-time size-total size-text size-data size-bss size-file Compare selected: Or click the "C" to compare with previous. Remotes without recent activity: LebedevRI MaskRay aeubanks anton-afanasyev chenzheng1030 dexonsmith dfukalov dobbelaj-snps fhahn mtrofin rotateright yuanfang-chen jmorse Melamoto smeijer1234 serge-sans-paille djolertrk zygoloid luismarques minglotus-6 mizvekov alexander-shaposhnikov alinas sunho luxufan yxsamliu weiguozhi tstellar dstenb OCHyams vitalybuka khei4 bcl5980 davidbolvansky goldsteinn dc03 cor3ntin jdoerfert jayfoad DianQK slinder1 RKSimon rnk Bryce-MW Endilll UsmanNadeem haopliu mark-sed jryans kovdan01 alexey-bataev topperc rastogishubham resistor XChy stuij artagnon AaronBallman Pierre-vh erikdesjardins huangjd Sirraide sdkrystian dougsonos 4vtomat paperchalice tobias-stadler ritter-x2a Chengjunp JOE1994 weihangf-apple madhur13490 lukel97 HanKuanChen ostannard michaelmaitland zyn0217 jmciver hokein pedroclobo s-barannikov efriedma-quic vortex73 DingdWang kasuga-fj fnriv cachemeifyoucan clemenswasser preames usx95 pcc noclowns JiachenYuan Remote nikic: Showing recent experiments. Show all nikic/perf/mi-flags-size: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 27ef52e5c7 60975M ( -0.03% ) 76744M (-0.00%) 89468M (-0.03%) 18478M (+0.02%) 68818M (-0.02%) 22671M (-0.01%) 52773M (+0.04%) 16172M (-0.05%) 35669500M (-0.00%) 3575501b5a 60995M 76746M 89491M 18475M 68830M 22673M 52754M 16181M 35669920M nikic/perf/opt-map: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C cf03e876f9 60957M ( -0.04% ) 76713M ( -0.04% ) 89445M ( -0.04% ) 18421M ( -0.14% ) 68766M ( -0.03% ) 22616M ( -0.12% ) 52729M ( -0.06% ) 16137M ( -0.12% ) 35624559M (+0.02%) 78f1de803a 60981M 76746M 89477M 18446M 68789M 22644M 52761M 16157M 35618571M Remote aengelke: Showing recent experiments. Show all aengelke/perf/domtreenums6-rebase: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 65eb5cc9c6 60733M (+0.02%) 76380M (+0.02%) 89163M ( +0.04% ) 18476M (+0.00%) 68555M (+0.02%) 22661M (+0.00%) 52506M (-0.01%) 16171M (-0.03%) 35574471M (-0.00%) C 5167b66d3f 60723M ( -0.44% ) 76363M ( -0.52% ) 89129M ( -0.40% ) 18475M (+0.00%) 68539M ( -0.43% ) 22661M (-0.04%) 52509M ( -0.52% ) 16176M (-0.01%) 35575373M ( -0.18% ) e8cceccea1 60990M 76761M 89488M 18475M 68835M 22669M 52784M 16177M 35640479M aengelke/perf/pch: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 81707618d4 61000M (+0.02%) 76751M (+0.00%) 89491M (+0.02%) 18470M (-0.00%) 68820M (-0.01%) 22670M (-0.01%) 52769M (-0.01%) 16172M (+0.01%) 21322700M ( +0.03% ) C 2d7a7d73bd 60986M (-0.01%) 76748M (-0.00%) 89474M (-0.01%) 18470M (-0.00%) 68829M (+0.00%) 22672M (+0.00%) 52773M (+0.01%) 16170M (-0.01%) 21315661M ( -3.22% ) C 70c05933a8 60992M (+0.01%) 76751M (+0.00%) 89484M (+0.01%) 18471M (-0.01%) 68826M (+0.00%) 22672M (-0.00%) 52767M (-0.03%) 16173M (-0.02%) 22025004M ( -12.95% ) C 8f7cb7f935 60988M (-0.02%) 76749M (-0.01%) 89478M (-0.01%) 18474M (-0.00%) 68823M (-0.02%) 22673M (-0.03%) 52782M (+0.01%) 16176M (+0.04%) 25300117M ( -5.65% ) C 2d1b3dbafc 60998M (+0.02%) 76756M (+0.01%) 89484M (+0.01%) 18474M (+0.01%) 68839M (+0.02%) 22680M ( +0.06% ) 52776M (-0.02%) 16170M (-0.04%) 26814747M ( -11.28% ) C d776a7e7bd 60984M (-0.00%) 76750M (-0.02%) 89471M (-0.01%) 18472M (-0.02%) 68822M (-0.01%) 22665M (-0.02%) 52788M (+0.01%) 16177M (-0.01%) 30223527M ( -15.11% ) C 4160076f71 60986M (-0.00%) 76765M (-0.00%) 89483M (-0.01%) 18476M (-0.01%) 68832M (+0.01%) 22669M (-0.00%) 52780M (+0.01%) 16178M (+0.01%) 35602998M (-0.01%) fbde9240e9 60989M 76765M 89491M 18477M 68828M 22670M 52774M 16176M 35605182M aengelke/perf/domtreenums6: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 77c8782276 60730M ( -0.44% ) 76364M ( -0.51% ) 89138M ( -0.40% ) 18478M (+0.00%) 68537M ( -0.42% ) 22657M ( -0.07% ) 52494M ( -0.56% ) 16177M (+0.04%) 35595785M ( -0.19% ) 263802c56b 60999M 76758M 89495M 18477M 68826M 22673M 52788M 16171M 35663899M aengelke/perf/constexpr-tli: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 965a8eeab8 60914M (-0.01%) 76670M (-0.02%) 89389M (-0.02%) 18501M (-0.01%) 68737M (-0.01%) 22693M (+0.03%) 52697M (-0.01%) 16184M (-0.06%) 35601127M (-0.00%) C 824cff366a 60919M (+0.01%) 76683M (+0.00%) 89411M (+0.01%) 18504M ( +0.04% ) 68747M (+0.00%) 22686M (-0.02%) 52700M (+0.01%) 16193M (+0.04%) 35601791M ( -0.09% ) 277069e8c1 60915M 76681M 89404M 18496M 68745M 22692M 52693M 16187M 35634592M aengelke/perf/pch2: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 5be1e67e1d 60936M (+0.00%) 76680M (-0.02%) 89416M (+0.00%) 18503M (-0.01%) 68756M (+0.00%) 22698M (+0.01%) 52698M (+0.01%) 16182M (+0.00%) 21510523M ( -0.15% ) C 92ca4a5d14 60935M (-0.00%) 76694M (+0.00%) 89415M (-0.01%) 18505M (+0.02%) 68754M (-0.00%) 22696M (+0.00%) 52694M (-0.02%) 16181M (-0.01%) 21542694M ( -3.12% ) C 45db8db438 60936M (-0.02%) 76692M (-0.01%) 89425M (-0.02%) 18502M ( -0.12% ) 68756M (-0.02%) 22696M ( -0.08% ) 52703M (-0.04%) 16182M ( -0.19% ) 22236808M ( -0.06% ) C f83f964d3a 60949M (+0.00%) 76698M (-0.01%) 89442M (-0.00%) 18523M (+0.02%) 68771M (+0.01%) 22715M (+0.02%) 52725M (-0.00%) 16213M (+0.02%) 22249328M (-0.02%) C 330e472e63 60947M (+0.00%) 76706M (+0.02%) 89445M (+0.01%) 18520M (-0.00%) 68767M (-0.00%) 22711M (-0.02%) 52725M (-0.00%) 16210M (-0.01%) 22252860M (-0.01%) C 06d5189659 60945M (-0.01%) 76694M (+0.00%) 89434M (-0.01%) 18520M (-0.00%) 68768M (-0.00%) 22715M (+0.01%) 52726M (+0.04%) 16211M (+0.04%) 22254102M ( -12.84% ) C 3d3e54e7a7 60950M (-0.00%) 76691M (-0.00%) 89440M (+0.01%) 18521M (-0.01%) 68769M (-0.01%) 22713M (-0.01%) 52704M (-0.00%) 16205M (-0.01%) 25533847M ( -5.63% ) C 1b605e083e 60951M (+0.01%) 76693M (+0.01%) 89430M (-0.01%) 18523M (-0.01%) 68774M (-0.00%) 22715M (+0.00%) 52705M (-0.00%) 16207M (-0.04%) 27058039M ( -11.14% ) C 2fbd73f57c 60944M ( +0.04% ) 76687M (-0.00%) 89435M (+0.02%) 18525M ( +0.16% ) 68777M ( +0.05% ) 22714M ( +0.08% ) 52707M (+0.02%) 16213M ( +0.14% ) 30449798M ( -14.54% ) C 0132e36f56 60921M (+0.01%) 76690M (+0.01%) 89420M (+0.01%) 18496M (+0.00%) 68742M (+0.00%) 22696M (+0.03%) 52694M (-0.00%) 16190M (-0.03%) 35631973M (-0.01%) C 684214fc7f 60916M (+0.00%) 76683M (+0.00%) 89411M (+0.01%) 18495M (-0.00%) 68739M (-0.01%) 22690M (-0.01%) 52695M (+0.00%) 16194M (+0.04%) 35636839M (+0.01%) 277069e8c1 60915M 76681M 89404M 18496M 68745M 22692M 52693M 16187M 35634592M aengelke/perf/no-cl-lambda: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C a0c8fdcf0a 60933M (+0.03%) 76684M (+0.00%) 89429M (+0.03%) 18492M (-0.02%) 68754M (+0.01%) 22688M (-0.01%) 52677M (-0.03%) 16179M (-0.05%) 35613219M ( -0.06% ) 277069e8c1 60915M 76681M 89404M 18496M 68745M 22692M 52693M 16187M 35634592M Remote tbaederr: Showing recent experiments. Show all tbaederr/perf/ce-test4: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C ffab8ed797 61118M (+0.03%) 76860M (+0.00%) 89581M (-0.02%) 18601M (+0.02%) 68947M (+0.01%) 22787M (+0.01%) 52863M (-0.05%) 16282M (+0.01%) 35653583M (+0.00%) C 854adac725 61098M (-0.02%) 76858M (+0.00%) 89597M (+0.01%) 18598M (-0.00%) 68942M (-0.00%) 22783M (-0.01%) 52889M (+0.00%) 16280M (+0.01%) 35652202M (-0.02%) C ff9d634483 61112M (-0.01%) 76856M (-0.01%) 89587M (-0.01%) 18598M (-0.01%) 68942M (-0.01%) 22786M (+0.01%) 52888M (+0.05%) 16278M (-0.00%) 35658168M ( +0.05% ) C 49ff927ffe 61120M (-0.00%) 76866M (+0.01%) 89595M (-0.00%) 18600M (+0.01%) 68952M (+0.02%) 22783M (-0.02%) 52863M (+0.01%) 16278M (+0.03%) 35639474M (+0.01%) C 003960ab5f 61121M (+0.01%) 76859M (-0.01%) 89597M (+0.01%) 18598M (-0.01%) 68941M (-0.01%) 22788M (+0.02%) 52860M (-0.05%) 16274M (-0.04%) 35635628M (+0.00%) C 51878c023c 61113M (+0.00%) 76864M (+0.01%) 89585M (+0.01%) 18600M ( +0.04% ) 68945M (+0.02%) 22783M (-0.02%) 52885M (+0.03%) 16280M (+0.04%) 35635229M ( +0.04% ) C 95f890cf6f 61111M (+0.01%) 76859M (+0.00%) 89574M (-0.01%) 18592M (-0.01%) 68934M (+0.00%) 22787M (+0.02%) 52866M (-0.02%) 16274M (-0.00%) 35619614M ( +0.03% ) C d8129e2130 61108M ( +0.16% ) 76858M ( +0.13% ) 89585M ( +0.12% ) 18594M ( +0.62% ) 68934M ( +0.15% ) 22783M ( +0.47% ) 52875M ( +0.17% ) 16275M ( +0.63% ) 35607719M ( -0.17% ) 8f182526de 61012M 76762M 89480M 18479M 68828M 22676M 52784M 16173M 35667924M Remote dtcxzyw: Showing recent experiments. Show all dtcxzyw/perf/fix-175018: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 103e605ce6 61040M (+0.01%) 76767M (-0.01%) 89525M (+0.02%) 18476M (-0.00%) 68840M (+0.01%) 22671M (+0.01%) 52765M (+0.00%) 16170M (-0.03%) 35655784M (-0.02%) C 6c43e292f6 61031M (-0.02%) 76771M (+0.00%) 89507M (-0.01%) 18477M (+0.02%) 68837M (-0.00%) 22667M (-0.01%) 52762M (-0.02%) 16174M (+0.01%) 35661561M (+0.01%) C 870f716857 61041M (+0.01%) 76768M (+0.00%) 89516M (-0.01%) 18474M (-0.02%) 68838M (+0.02%) 22671M (+0.01%) 52773M (+0.01%) 16173M (-0.01%) 35657768M (-0.00%) C c357f22387 61037M (+0.00%) 76766M (+0.00%) 89523M (+0.02%) 18478M (+0.02%) 68827M (-0.02%) 22668M (-0.00%) 52767M (+0.03%) 16175M (+0.01%) 35657772M (+0.01%) C 2ad6cfb839 61035M (-0.01%) 76763M (-0.01%) 89505M (-0.02%) 18474M (+0.00%) 68842M (+0.01%) 22669M (-0.02%) 52753M (+0.01%) 16174M (-0.01%) 35655782M (+0.01%) ded109c0cf 61044M 76769M 89520M 18473M 68837M 22674M 52749M 16176M 35652902M Remote antoniofrighetto: Showing recent experiments. Show all antoniofrighetto/perf/add-capturesbeforeanalysis: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 1d1a4d4a09 60900M (-0.00%) 76663M (+0.00%) 89410M (+0.01%) 18501M (+0.03%) 68756M (+0.01%) 22690M (-0.01%) 52668M (-0.01%) 16189M (+0.02%) 35632763M (+0.01%) 448f5fe41b 60902M 76662M 89398M 18497M 68751M 22692M 52675M 16186M 35629438M antoniofrighetto/perf/cgp-duplicate-for-tail: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 865721cff4 60923M (+0.00%) 76680M (-0.01%) 89401M (+0.01%) 18497M (+0.01%) 68778M (+0.01%) 22689M (+0.02%) 52674M (+0.02%) 16179M (-0.02%) 35603368M (+0.01%) 24f0c26dd0 60922M 76688M 89395M 18495M 68773M 22685M 52661M 16181M 35598983M Remote john-brawn-arm: Showing recent experiments. Show all john-brawn-arm/perf/lsr_disable_collapsing_unrolled: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 19983f44aa 60916M (-0.02%) 76682M (-0.01%) 89422M (+0.01%) 18499M (+0.01%) 68782M (+0.01%) 22682M (-0.03%) 52687M (+0.01%) 16176M (+0.00%) 35603155M (+0.00%) 7e2b79b049 60925M 76693M 89411M 18496M 68776M 22690M 52679M 16176M 35601431M Remote Thibault-Monnier: Showing recent experiments. Show all Thibault-Monnier/perf/charinfo: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang C 92cb276808 60986M (+0.02%) 76754M (+0.00%) 89487M (+0.00%) 18455M ( +0.06% ) 68808M (+0.01%) 22655M ( +0.05% ) 52793M ( +0.10% ) 16181M ( +0.18% ) 35615117M (+0.00%) 66df6cceea 60975M 76754M 89483M 18444M 68798M 22642M 52740M 16151M 35613836M Remote origin: Showing recent experiments. Show all origin/main: Commit stage1-O3 stage1-ReleaseThinLTO stage1-ReleaseLTO-g stage1-O0-g stage1-aarch64-O3 stage1-aarch64-O0-g stage2-O3 stage2-O0-g stage2-clang ef90ba684d e884a44cdd 620e479d23 b598dcbd75 b685bf0032 C e9f758a59b 60986M (+0.00%) 76760M (-0.00%) 89485M (-0.01%) 18472M (-0.02%) 68826M (+0.00%) 22674M (+0.01%) 52794M (+0.01%) 16171M (-0.00%) 35609840M (-0.01%) afd7d13d14 C e3156c531d 60985M (-0.01%) 76763M (-0.00%) 89491M (+0.01%) 18475M (+0.00%) 68825M (-0.01%) 22671M (+0.01%) 52789M (+0.03%) 16172M (-0.01%) 35614002M (-0.02%) 6cbf9cef58 C c4750d0575 60991M (+0.01%) 76764M (+0.01%) 89485M (-0.01%) 18474M (-0.02%) 68833M (+0.00%) 22670M (+0.01%) 52773M (-0.04%) 16173M (-0.00%) 35620439M (+0.00%) dc1a886fb9 2001da6fd3 C af98aadc63 60988M (+0.01%) 76757M (-0.00%) 89495M (-0.00%) 18478M (+0.00%) 68830M (+0.01%) 22667M (-0.01%) 52795M (-0.01%) 16173M (-0.01%) 35619791M (+0.02%) C ef2ec1fbac 60984M (-0.01%) 76757M (-0.01%) 89497M (+0.02%) 18477M (+0.00%) 68826M (+0.01%) 22670M (-0.01%) 52801M (+0.03%) 16174M (+0.03%) 35614427M (-0.00%) dc257a4609 124cb2ec9d 2b839f66ae C a0e0775d91 60988M (-0.00%) 76768M (+0.02%) 89478M (-0.02%) 18477M (+0.01%) 68822M (-0.00%) 22672M (+0.02%) 52786M (-0.01%) 16169M (-0.03%) 35615359M (+0.02%) C e4b8d8a474 60990M (+0.00%) 76756M (-0.00%) 89499M (+0.01%) 18474M (-0.01%) 68824M (-0.00%) 22667M (-0.01%) 52789M (-0.01%) 16173M (+0.02%) 35608803M (-0.01%) C bd28c6ac9a 60988M (-0.01%) 76757M (-0.01%) 89493M (-0.01%) 18477M (+0.02%) 68825M (-0.00%) 22668M (-0.01%) 52793M (+0.01%) 16171M ( -0.07% ) 35612925M (+0.00%) bb008e7417 9e1606026c C ee3f4bc92f 60993M (+0.00%) 76763M (+0.01%) 89502M (+0.02%) 18473M (-0.00%) 68828M (-0.00%) 22671M (-0.03%) 52788M (+0.02%) 16182M (-0.01%) 35611918M (-0.01%) C da94edf535 60992M (+0.01%) 76756M (-0.01%) 89487M (-0.00%) 18473M (+0.00%) 68831M (+0.01%) 22678M (+0.03%) 52779M (+0.00%) 16184M (+0.06%) 35615965M (+0.01%) 77613aa7ea 13cd7003ad a01b7c23c4 ed9f5c93dc 438f887080 2329d0436f f9c561b561 26624d51d1 a9037dc957 587bac637c C c6fc6adb7e 60984M (-0.01%) 76761M (+0.01%) 89489M (+0.01%) 18473M (-0.00%) 68824M (-0.01%) 22671M (+0.01%) 52779M (+0.00%) 16174M (-0.03%) 35612604M (+0.00%) e4b22017df 1b69dfeaf8 9596c9242f 30596a0b03 12ecbfb59b 998e0aed7b 393ba8c0dc 552a696a71 af4427d5a4 C 5e256017ba 60989M (-0.00%) 76757M (-0.01%) 89483M (-0.02%) 18473M (+0.00%) 68828M (-0.00%) 22669M (-0.01%) 52777M (-0.01%) 16179M (-0.01%) 35611493M (-0.00%) a8ba9c4fa2 3874c4541a 3fe94ab4d6 1c8627fbf3 014d2b9d9f 44df98e963 C 1023f91d3d 60990M (+0.01%) 76763M (+0.01%) 89497M (+0.01%) 18473M (-0.01%) 68831M (+0.01%) 22670M (+0.01%) 52780M (-0.01%) 16181M (+0.06%) 35611737M (+0.01%) 0828533645 496729fe7e C 5c764b4e3c 60985M (-0.01%) 76758M (+0.00%) 89488M (-0.01%) 18475M (-0.01%) 68825M (+0.00%) 22669M (+0.00%) 52786M (+0.01%) 16172M (-0.01%) 35607678M (-0.00%) fa36b0cdb0 C f9a8096067 60992M (+0.01%) 76758M (-0.00%) 89495M (+0.01%) 18476M (+0.01%) 68825M (+0.00%) 22668M (-0.02%) 52779M (+0.00%) 16173M (+0.01%) 35608093M (-0.01%) C 55e7a89fd3 60988M (+0.00%) 76760M (-0.00%) 89487M (-0.02%) 18473M (-0.02%) 68822M (-0.02%) 22672M (+0.01%) 52779M (+0.01%) 16171M (-0.04%) 35613406M (-0.00%) 12131c9f8d 71293e4495 b491241734 c259ed51a3 d07062acd4 62c97aa519 C a062249932 60987M (+0.00%) 76762M (-0.00%) 89500M (+0.02%) 18477M (+0.00%) 68832M (+0.02%) 22670M (+0.01%) 52775M (-0.01%) 16177M (+0.04%) 35613651M (-0.01%) be518278fd e4d2e4c27b 0fedcf9fbc 37ac7842a3 9cd7908d5f C 7275248f41 60987M (-0.01%) 76764M (+0.01%) 89486M (-0.01%) 18477M (+0.01%) 68822M (-0.01%) 22667M (-0.03%) 52778M (+0.00%) 16171M (-0.02%) 35615939M (+0.01%) a76dbdd268 C ba76e02d67 60991M (+0.01%) 76756M (-0.00%) 89499M (-0.00%) 18474M (-0.00%) 68828M (+0.02%) 22673M (-0.00%) 52778M (-0.01%) 16175M (+0.01%) 35610715M (+0.00%) 3cfae43d07 C 5334c51486 60986M (-0.01%) 76756M (-0.01%) 89501M (+0.01%) 18474M (+0.00%) 68817M (-0.02%) 22673M (+0.01%) 52783M (+0.01%) 16173M (+0.01%) 35609446M (+0.01%) 55ba30bd37 57e4ff2681 C 70bd0e2273 60990M (-0.00%) 76761M (-0.00%) 89492M (+0.01%) 18474M (-0.02%) 68831M (-0.00%) 22672M (+0.01%) 52775M (-0.02%) 16172M (-0.02%) 35607372M (-0.00%) 0815ed34b8 C 564c0c169f 60990M (+0.01%) 76761M (+0.00%) 89484M (-0.00%) 18478M (+0.02%) 68833M (+0.00%) 22669M (-0.00%) 52784M (+0.02%) 16176M (+0.00%) 35607876M (-0.02%) C c152a0b9b0 60986M (-0.00%) 76759M (-0.01%) 89486M (+0.01%) 18475M (+0.00%) 68832M (+0.00%) 22670M (-0.00%) 52772M (+0.02%) 16176M (+0.02%) 35614300M (-0.00%) 38cb7ddca2 dae3b49cba C d514b32c23 60988M (+0.00%) 76765M (+0.01%) 89481M (-0.02%) 18474M (-0.01%) 68830M (-0.01%) 22671M (-0.00%) 52763M (-0.00%) 16172M (-0.01%) 35614929M (+0.02%) C b76c84e70f 60987M (+0.00%) 76758M (-0.00%) 89500M (+0.01%) 18476M (+0.01%) 68837M (+0.01%) 22671M (+0.01%) 52764M (+0.00%) 16174M (+0.01%) 35608610M (+0.01%) C 7d96b39c4f 60987M (+0.00%) 76759M (-0.01%) 89487M (-0.00%) 18473M (-0.01%) 68828M (-0.01%) 22670M (+0.00%) 52763M (-0.04%) 16172M (-0.03%) 35604230M (-0.01%) dbe3e9b019 C 9f6f16563f 60986M (-0.00%) 76768M (+0.00%) 89488M (+0.00%) 18475M (+0.01%) 68833M (-0.00%) 22669M (-0.01%) 52783M (+0.02%) 16178M (+0.02%) 35607128M (+0.00%) 47f744ac15 496824017e C 0c9919d7ea 60989M (-0.00%) 76767M (+0.00%) 89484M (-0.01%) 18474M (-0.02%) 68834M (+0.01%) 22673M (+0.01%) 52773M (-0.00%) 16174M (-0.01%) 35605407M (+0.00%) b4df4695f7 9f0d0bbaf4 acf82c1083 9007f1dd45 b595849e7c C fbde9240e9 60989M (+0.01%) 76765M (+0.01%) 89491M (-0.01%) 18477M (+0.04%) 68828M (+0.00%) 22670M (-0.00%) 52774M (-0.02%) 16176M (-0.01%) 35605182M (-0.00%) 1232599032 6b674e5605 21b3b37dbb 150c8b022c c208e42225 bbcab0bf57 5db5782da1 8fb1200c95 d7ee9f2141 C 8042c93a58 60985M (-0.01%) 76759M (+0.00%) 89497M (+0.02%) 18470M (-0.01%) 68827M (+0.00%) 22671M (-0.01%) 52785M (+0.02%) 16178M (+0.02%) 35605833M (+0.02%) C 501416a755 60988M (-0.01%) 76759M (-0.01%) 89479M (-0.01%) 18473M (-0.02%) 68827M (-0.00%) 22673M (+0.01%) 52776M (-0.01%) 16175M (+0.00%) 35600244M ( -0.13% ) C acfc31a4a7 60992M (+0.01%) 76768M (+0.01%) 89492M (+0.01%) 18477M (-0.00%) 68829M (-0.00%) 22671M (-0.01%) 52782M (-0.00%) 16175M (+0.03%) 35645580M (+0.00%) C dbd52bd558 60986M (+0.00%) 76759M (+0.00%) 89487M (+0.01%) 18477M (+0.02%) 68829M (+0.01%) 22673M (+0.02%) 52783M (+0.02%) 16169M (-0.02%) 35644795M (+0.00%) 21aa00b916 C 5f9092a19b 60985M (-0.01%) 76758M (-0.00%) 89479M (-0.01%) 18474M (-0.00%) 68823M (-0.02%) 22669M (-0.00%) 52774M (-0.02%) 16172M (-0.03%) 35644116M (+0.01%) 8821654715 0a45652bc3 c80d20daa1 05c769e062 C e8cceccea1 60990M (+0.01%) 76761M (-0.01%) 89488M (+0.01%) 18475M (+0.02%) 68835M (+0.01%) 22669M (-0.01%) 52784M (+0.03%) 16177M (+0.02%) 35640479M (-0.01%) 774ea531ea d0235a150d 8e8a5502cb 9f3551154c d28daddd2b 88f4c0a103 e6691b08c8 ccbe36f16d C 9057744221 60985M (+0.01%) 76766M (+0.00%) 89482M (-0.00%) 18471M (-0.02%) 68826M (+0.00%) 22672M (-0.01%) 52770M (+0.00%) 16174M (+0.01%) 35644151M (-0.00%) 7e7d9dc0ee 4191b0cd0f 619a9c1e81 47910d62fe C effa813844 60981M (-0.01%) 76765M (+0.01%) 89482M (-0.00%) 18475M (-0.00%) 68825M (-0.00%) 22675M (+0.03%) 52768M (+0.01%) 16173M (+0.01%) 35645656M (+0.01%) C 7676471c70 60985M ( -0.05% ) 76758M (-0.01%) 89485M (-0.01%) 18475M (-0.02%) 68825M (-0.01%) 22667M (-0.02%) 52764M (-0.02%) 16172M ( -0.09% ) 35642956M (-0.01%) C ad38c3987f 61013M (+0.02%) 76767M (+0.00%) 89492M (+0.01%) 18480M (-0.01%) 68835M (+0.00%) 22672M (-0.00%) 52772M (-0.02%) 16187M ( +0.08% ) 35644966M ( -0.07% ) C 2cfa9b258e 61004M (+0.00%) 76766M (-0.00%) 89481M (-0.01%) 18481M (+0.02%) 68834M (+0.01%) 22672M (+0.00%) 52782M (+0.01%) 16173M (-0.02%) 35668976M (+0.01%) C 50c1a69db0 61002M (-0.01%) 76766M (+0.02%) 89494M (+0.02%) 18478M (-0.02%) 68826M (+0.01%) 22671M (+0.00%) 52774M (+0.00%) 16176M (-0.00%) 35666837M (+0.00%) C f4217fd4a3 61010M (+0.01%) 76754M (-0.01%) 89478M (-0.01%) 18481M (+0.02%) 68821M (-0.01%) 22671M (+0.01%) 52774M (-0.00%) 16177M (-0.01%) 35665507M (-0.01%) C 6ff416cabc 61001M (-0.02%) 76761M (-0.00%) 89484M (+0.00%) 18479M (+0.01%) 68825M (+0.01%) 22668M (-0.02%) 52775M (-0.03%) 16179M (-0.03%) 35668833M (+0.00%) C e289b2e765 61013M (+0.02%) 76762M (+0.00%) 89483M (-0.01%) 18477M (-0.00%) 68822M (-0.01%) 22674M (+0.00%) 52792M (+0.02%) 16184M (+0.02%) 35667979M (-0.00%) C ab34189878 61000M (-0.01%) 76760M (+0.00%) 89497M (+0.00%) 18477M (-0.01%) 68825M (+0.01%) 22673M (+0.01%) 52781M (-0.01%) 16181M (+0.06%) 35669493M (+0.00%) de9120dd3b f6d0a51297 C 02bc04f726 61006M (+0.02%) 76758M (-0.00%) 89494M (+0.00%) 18479M (+0.00%) 68815M (-0.01%) 22671M (-0.03%) 52786M (+0.02%) 16172M (-0.01%) 35668102M (+0.01%) 01e9c20aa2 d5e610a6dc 01e089ee5e 48d163684c 669d71be6f 9ad052edbf C 9c5708c257 60997M (-0.01%) 76759M (-0.00%) 89490M (-0.01%) 18479M (+0.00%) 68823M (-0.00%) 22677M (+0.03%) 52777M (+0.02%) 16175M (-0.03%) 35663467M (-0.01%) 98640226ba a698f7ebdf fd90b7cd1f e531f48fc4 68239d53c5 123b6a2766 C 04e5bc7dfb 61004M (+0.02%) 76761M (+0.00%) 89503M (+0.02%) 18478M (-0.01%) 68823M (-0.00%) 22671M (+0.01%) 52769M (-0.02%) 16179M (+0.03%) 35665594M (+0.00%) C 3c45c54156 60992M (-0.01%) 76761M (-0.00%) 89488M (+0.00%) 18480M (+0.01%) 68825M (-0.01%) 22669M (-0.01%) 52779M (+0.01%) 16174M (+0.00%) 35665023M (-0.01%) C 16078f07c4 60999M (+0.00%) 76761M (-0.01%) 89487M (+0.00%) 18479M (-0.01%) 68833M (+0.01%) 22671M (-0.01%) 52774M (-0.01%) 16173M (-0.01%) 35669934M (+0.01%) C 527d0afcb7 60996M (+0.01%) 76765M (-0.00%) 89485M (-0.01%) 18482M (+0.03%) 68825M (+0.01%) 22672M (-0.00%) 52779M (+0.02%) 16175M (+0.01%) 35667863M (+0.01%) b22c149770 f2ba54ad4f f73f43cf50 b9859d05fd 128731fbd3 C 26e10cda55 60989M (-0.03%) 76766M (+0.01%) 89494M (+0.00%) 18477M (+0.00%) 68821M (-0.01%) 22673M (+0.02%) 52766M (-0.02%) 16173M (+0.02%) 35665294M (+0.01%) 194a4d2e93 C b04cf3b0fd 61007M (-0.01%) 76760M (+0.01%) 89492M (+0.01%) 18476M (-0.03%) 68830M (-0.00%) 22667M (-0.01%) 52775M (-0.00%) 16170M (-0.03%) 35661029M (-0.02%) C 670ecd7c35 61013M (+0.02%) 76755M (-0.01%) 89485M (-0.00%) 18481M (+0.02%) 68831M (+0.01%) 22670M (-0.01%) 52776M (-0.01%) 16174M (-0.03%) 35667836M (+0.00%) 52d6170c9f a823a2ab6d 27074aa31a 48a5c1dc5c 46016e63b7 C 03e1a4329d 61001M (+0.00%) 76764M (+0.01%) 89488M (-0.01%) 18478M (+0.00%) 68825M (-0.00%) 22672M (-0.00%) 52779M (-0.02%) 16178M (+0.04%) 35667344M (+0.01%) 3b2d14ba1c 185f078a6f C 263802c56b 60999M (+0.01%) 76758M (-0.00%) 89495M (-0.00%) 18477M (-0.00%) 68826M (-0.00%) 22673M (+0.02%) 52788M (-0.02%) 16171M (-0.03%) 35663899M (-0.01%) 2220c00d6d b983b0e92a C 14e97d649b 60991M (-0.02%) 76760M (-0.00%) 89499M (+0.00%) 18477M (-0.01%) 68829M (-0.00%) 22668M (-0.01%) 52800M (+0.03%) 16176M (-0.02%) 35666630M (+0.00%) C e66123080c 61000M (-0.00%) 76763M (+0.00%) 89494M (-0.01%) 18479M (+0.01%) 68830M (+0.01%) 22670M (+0.00%) 52786M (-0.03%) 16178M (+0.02%) 35666464M (-0.01%) C 51ee583b1a 61000M (+0.00%) 76760M (+0.00%) 89504M (+0.02%) 18477M (-0.02%) 68823M (-0.00%) 22669M (-0.00%) 52804M (+0.00%) 16174M (-0.02%) 35669196M (-0.01%) C 8380b57b7e 60999M (-0.02%) 76758M (-0.00%) 89486M (+0.01%) 18481M (+0.01%) 68823M (-0.01%) 22669M (-0.03%) 52802M (+0.03%) 16177M (+0.02%) 35672407M (+0.01%) 0275c9fa5f ce4fcfc9e4 ff005aaa48 4790a14199 424998c5e5 C 8f182526de 61012M (+0.01%) 76762M (+0.00%) 89480M (-0.00%) 18479M (-0.02%) 68828M (+0.00%) 22676M (+0.04%) 52784M (+0.03%) 16173M (+0.00%) 35667924M (-0.00%) 4415ea5bd3 b574f44a7d C 3dfb782333 61005M (-0.01%) 76760M (+0.00%) 89483M (-0.00%) 18482M (+0.00%) 68825M (-0.01%) 22666M (-0.02%) 52766M (-0.02%) 16173M (-0.03%) 35668509M (-0.01%) a6378b66fe 2a8be8bd73 C ac62f12192 61011M (+0.02%) 76759M (-0.01%) 89485M (-0.01%) 18482M (-0.00%) 68829M (-0.00%) 22672M (-0.01%) 52777M (+0.01%) 16178M (+0.00%) 35672132M (-0.01%) C f0982d5d44 60999M (-0.01%) 76764M (-0.01%) 89493M (-0.00%) 18482M (+0.00%) 68831M (+0.01%) 22674M (+0.00%) 52774M (-0.00%) 16178M (+0.00%) 35675077M (+0.00%) C 4cec62299d 61005M (+0.00%) 76768M (+0.01%) 89493M (+0.01%) 18481M (-0.00%) 68825M (-0.01%) 22673M (+0.00%) 52776M (-0.01%) 16177M (+0.02%) 35674027M (+0.00%) 91268a50f2 b646209ddc C 9a632fd684 61003M (-0.00%) 76761M (-0.00%) 89482M (-0.01%) 18482M (+0.00%) 68834M (+0.00%) 22673M (-0.00%) 52781M (+0.00%) 16174M (-0.01%) 35673027M (-0.01%) C 6bde19f4bb 61006M (-0.01%) 76763M (-0.00%) 89488M (-0.01%) 18481M (+0.00%) 68830M (-0.01%) 22674M (-0.00%) 52778M (+0.01%) 16176M (+0.00%) 35674884M (-0.01%) C e51f25a3ca 61012M (+0.02%) 76763M (-0.00%) 89500M (+0.01%) 18481M (+0.01%) 68834M (+0.00%) 22674M (+0.00%) 52772M ( -0.06% ) 16176M (-0.00%) 35680006M (+0.02%) C fcff5b0765 60999M (-0.00%) 76765M (+0.00%) 89494M (+0.01%) 18479M (-0.02%) 68834M (+0.00%) 22673M (-0.00%) 52802M (+0.01%) 16176M (-0.01%) 35674602M (-0.01%) 19317ad1d9 C e5b6833e49 61001M (-0.00%) 76763M (-0.00%) 89487M (+0.00%) 18482M (+0.02%) 68833M (-0.01%) 22674M (+0.00%) 52795M (-0.00%) 16178M (+0.01%) 35677573M (+0.01%) 9725cb8ede C a5fa246435 61004M (+0.00%) 76766M (-0.01%) 89487M (-0.01%) 18480M (-0.03%) 68839M (+0.01%) 22673M (+0.02%) 52797M ( +0.07% ) 16177M (-0.00%) 35674321M ( -0.02% ) C 43138d6272 61003M (+0.02%) 76772M (+0.02%) 89494M (+0.01%) 18486M ( +0.05% ) 68832M (-0.01%) 22669M (-0.00%) 52757M (+0.01%) 16178M (-0.00%) 35682979M (+0.01%) C 966c95f6d4 60991M (+0.00%) 76758M (-0.00%) 89483M (-0.02%) 18476M (-0.02%) 68836M (+0.00%) 22670M (-0.01%) 52751M (+0.01%) 16178M (-0.01%) 35677991M (+0.01%) C 1f1dee3b2e 60988M (-0.01%) 76759M (+0.02%) 89499M (+0.01%) 18480M (+0.02%) 68836M (+0.01%) 22672M (-0.01%) 52747M (-0.01%) 16180M (-0.00%) 35672825M (+0.01%) C 3575501b5a 60995M (+0.01%) 76746M (-0.01%) 89491M (+0.01%) 18475M (-0.03%) 68830M (-0.00%) 22673M (-0.01%) 52754M (+0.00%) 16181M (+0.02%) 35669920M (+0.00%) 743f0a4fdb C 145e28d061 60987M (-0.01%) 76757M (-0.01%) 89482M (-0.00%) 18481M (+0.02%) 68831M (+0.00%) 22675M (+0.02%) 52752M (-0.01%) 16178M (-0.00%) 35668897M (-0.00%) C f827c20ccf 60991M (-0.01%) 76763M (+0.01%) 89485M (-0.01%) 18477M (+0.00%) 68829M (+0.01%) 22670M (-0.01%) 52757M (-0.00%) 16179M (-0.01%) 35669984M (-0.01%) C ba6a59c875 60996M (+0.01%) 76758M (+0.01%) 89490M (+0.00%) 18477M (+0.00%) 68822M (-0.02%) 22672M (+0.00%) 52757M (+0.02%) 16180M (-0.02%) 35674136M (+0.02%) C f114d95926 60991M (+0.00%) 76752M (-0.01%) 89487M (+0.00%) 18477M (-0.01%) 68836M (-0.01%) 22671M (+0.01%) 52746M (-0.01%) 16183M (+0.04%) 35667733M (-0.02%) C 79a1b80af8 60990M (-0.01%) 76758M (+0.00%) 89487M (-0.01%) 18479M (-0.00%) 68841M (+0.02%) 22669M (+0.01%) 52750M (+0.00%) 16177M (-0.02%) 35674181M (-0.00%) C 67601a43b5 60994M (+0.01%) 76758M (-0.01%) 89499M (+0.03%) 18479M (-0.00%) 68828M (+0.00%) 22668M (+0.00%) 52750M (-0.00%) 16180M (-0.02%) 35675105M (+0.01%) C 564f2be43f 60990M (-0.00%) 76763M (+0.00%) 89471M (-0.02%) 18480M (+0.01%) 68827M (-0.01%) 22667M (-0.03%) 52752M (+0.01%) 16183M (+0.02%) 35671906M (+0.01%) C a3ca7caa74 60991M (-0.01%) 76760M (+0.01%) 89489M (-0.01%) 18479M (+0.00%) 68833M (+0.02%) 22674M (+0.01%) 52749M (-0.00%) 16179M (-0.01%) 35668687M ( -0.02% ) C e0cf581ad4 60996M (+0.00%) 76752M (-0.00%) 89493M (+0.00%) 18478M (+0.01%) 68823M (-0.01%) 22672M (+0.01%) 52751M (+0.01%) 16180M (+0.02%) 35675939M (+0.00%) C bdc6a6778d 60995M (+0.01%) 76752M (-0.01%) 89489M (-0.02%) 18476M (-0.01%) 68830M (+0.00%) 22669M (-0.02%) 52748M (+0.01%) 16177M (+0.00%) 35675340M (+0.01%) 187ca8609a C 91dafc7f40 60990M (-0.00%) 76762M (+0.01%) 89505M (+0.01%) 18477M (-0.01%) 68830M (-0.00%) 22673M (+0.01%) 52745M (+0.00%) 16176M (+0.01%) 35671083M (-0.01%) C 79be97d90a 60991M (+0.00%) 76756M (-0.00%) 89496M (+0.01%) 18478M (+0.02%) 68833M (-0.02%) 22671M (+0.00%) 52745M (+0.00%) 16174M (-0.00%) 35673933M ( -0.03% ) C 458a983df4 60990M (+0.00%) 76758M (+0.01%) 89486M (-0.01%) 18475M (-0.02%) 68845M ( +0.03% ) 22671M (-0.00%) 52744M (-0.00%) 16174M (-0.01%) 35683624M ( +0.04% ) C cd2caf6580 60990M (-0.00%) 76750M (-0.00%) 89498M (+0.01%) 18479M (-0.00%) 68822M (-0.02%) 22671M (-0.00%) 52745M (-0.01%) 16176M (-0.03%) 35670238M (+0.00%) C ee8a4bc9d7 60992M (-0.00%) 76754M (-0.00%) 89491M (+0.00%) 18480M (+0.01%) 68838M (+0.02%) 22672M (+0.00%) 52752M (+0.00%) 16181M (-0.00%) 35669558M ( -0.02% ) C 81d5b36f34 60992M (+0.01%) 76757M (-0.00%) 89489M (+0.01%) 18477M (+0.01%) 68825M (-0.01%) 22671M (-0.00%) 52752M (-0.01%) 16182M (+0.03%) 35677182M (+0.00%) C dcf8ae8028 60989M (+0.00%) 76757M (-0.00%) 89481M (-0.02%) 18476M (-0.03%) 68830M (-0.01%) 22671M (+0.01%) 52755M (+0.01%) 16177M (-0.01%) 35676907M ( +0.02% ) C 282f8f79d7 60989M (-0.00%) 76758M (-0.00%) 89497M (+0.02%) 18482M ( +0.04% ) 68838M (+0.01%) 22670M (-0.02%) 52751M (+0.00%) 16180M (+0.01%) 35669610M (+0.00%) C f091be6d53 60989M (+0.00%) 76760M (+0.02%) 89477M (-0.01%) 18474M (-0.02%) 68832M (-0.01%) 22675M (+0.03%) 52749M (-0.01%) 16179M (-0.01%) 35668046M ( -0.03% ) C bc51c9d5f2 60988M (-0.00%) 76747M (-0.01%) 89488M (-0.00%) 18477M (-0.02%) 68841M (+0.00%) 22668M (-0.00%) 52753M (-0.00%) 16181M (+0.01%) 35676979M (+0.00%) C c726fff61c 60989M (-0.00%) 76751M (-0.01%) 89488M (-0.00%) 18480M (+0.01%) 68840M (+0.00%) 22669M (-0.02%) 52755M (+0.01%) 16179M (+0.02%) 35675346M (+0.02%) C 2f7e218017 60990M (+0.00%) 76759M (-0.00%) 89489M (-0.01%) 18479M (+0.00%) 68837M (+0.00%) 22673M (+0.01%) 52749M ( -0.06% ) 16176M (+0.00%) 35669806M (-0.01%) C c6db8f4229 60989M (+0.00%) 76761M (+0.01%) 89496M (+0.01%) 18478M (-0.01%) 68835M (+0.01%) 22670M (-0.01%) 52778M (+0.01%) 16175M (-0.02%) 35674132M (+0.00%) C eba79bc335 60988M (+0.01%) 76752M (-0.00%) 89486M (-0.00%) 18481M (+0.02%) 68827M (-0.01%) 22672M (+0.01%) 52774M ( +0.06% ) 16178M (+0.04%) 35673028M (+0.00%) C 3ad028173b 60985M (-0.01%) 76755M (+0.01%) 89486M (+0.01%) 18477M (-0.00%) 68836M (+0.00%) 22670M (+0.00%) 52741M (+0.01%) 16172M (-0.01%) 35672096M (+0.01%) C f987bbddda 60994M (+0.00%) 76750M (+0.01%) 89476M (-0.02%) 18477M (-0.01%) 68833M (-0.02%) 22669M (-0.00%) 52737M (-0.01%) 16174M (+0.00%) 35669457M (-0.00%) C 1c0c9aeae6 60992M (+0.00%) 76746M (-0.02%) 89493M (+0.00%) 18479M (-0.01%) 68845M (+0.01%) 22670M (-0.02%) 52741M (-0.00%) 16174M (-0.00%) 35670199M (-0.01%) C e7f23b410b 60990M (-0.00%) 76759M (+0.01%) 89490M (-0.00%) 18481M (+0.01%) 68836M (+0.01%) 22674M (+0.01%) 52742M (+0.01%) 16175M (+0.02%) 35672852M (+0.01%) C 8877491388 60991M (+0.01%) 76754M (+0.02%) 89490M (+0.01%) 18480M (-0.01%) 68830M (+0.00%) 22671M (-0.01%) 52739M (-0.03%) 16172M (-0.02%) 35669284M (+0.00%) C 3448695896 60988M (+0.00%) 76741M (-0.01%) 89480M (-0.00%) 18481M (+0.03%) 68830M (+0.01%) 22673M (+0.01%) 52754M (-0.00%) 16175M (+0.01%) 35669097M (+0.00%) C f25ddef036 60985M (-0.01%) 76750M (+0.00%) 89481M (-0.00%) 18475M (-0.02%) 68823M (-0.01%) 22671M (-0.00%) 52756M (+0.00%) 16173M (+0.00%) 35668331M (+0.00%) C 363903eb3e 60989M (+0.01%) 76749M (+0.00%) 89481M (+0.01%) 18479M (-0.01%) 68828M (+0.00%) 22671M (-0.01%) 52755M (-0.00%) 16172M (-0.01%) 35667552M (-0.01%) a779fdffe9 C 76ce034977 60985M (-0.00%) 76746M (-0.02%) 89474M (-0.01%) 18481M (+0.02%) 68828M (+0.00%) 22673M (+0.01%) 52757M (+0.02%) 16175M (+0.02%) 35671040M (+0.00%) C 362b653c69 60987M (-0.00%) 76758M (+0.01%) 89483M (+0.01%) 18477M (+0.02%) 68828M (+0.00%) 22671M (+0.01%) 52747M (+0.00%) 16171M (-0.05%) 35670382M (-0.00%) C 3920bc61ca 60989M (+0.00%) 76752M (+0.01%) 89477M (-0.01%) 18474M (-0.01%) 68826M (+0.00%) 22668M (-0.00%) 52745M (-0.02%) 16179M (-0.01%) 35671169M (+0.00%) 99ab1dd145 C 1cb9b790f0 60987M (+0.01%) 76746M (-0.01%) 89485M (+0.00%) 18477M (-0.00%) 68824M (-0.01%) 22668M (-0.00%) 52758M (-0.01%) 16180M (-0.01%) 35670460M (-0.02%) C d620ea7657 60980M (-0.01%) 76752M (+0.01%) 89484M (-0.01%) 18477M (-0.00%) 68832M (+0.01%) 22669M (-0.01%) 52763M (+0.02%) 16182M (+0.03%) 35676543M ( +0.03% ) C 12cccb96de 60986M (+0.00%) 76748M (-0.00%) 89489M (+0.01%) 18478M (-0.01%) 68828M (+0.00%) 22671M (-0.00%) 52754M (+0.02%) 16177M (+0.02%) 35667064M (-0.00%) 7e4f390c38 C 48a6157eb0 60984M (-0.00%) 76748M (-0.00%) 89479M (-0.00%) 18479M (+0.00%) 68827M (+0.01%) 22672M (-0.01%) 52746M (+0.01%) 16173M (-0.00%) 35667863M (-0.00%) 1d4743e1bc C 6559bdab61 60984M (+0.01%) 76752M (+0.00%) 89483M (+0.01%) 18479M (-0.01%) 68819M (-0.00%) 22674M (-0.00%) 52739M (-0.02%) 16174M (+0.01%) 35669017M (-0.01%) C 9466e285f6 60977M (-0.01%) 76748M (+0.00%) 89476M (-0.00%) 18481M (+0.01%) 68822M (+0.01%) 22674M (+0.02%) 52750M (+0.03%) 16172M (-0.01%) 35673820M (+0.01%) C 62d4aa1ad8 60985M (+0.00%) 76747M (+0.01%) 89479M (+0.01%) 18478M (-0.00%) 68818M ( -0.03% ) 22669M (-0.02%) 52737M (-0.00%) 16174M (+0.01%) 35670673M (+0.01%) C 8b53523163 60984M (-0.01%) 76743M (-0.01%) 89468M (-0.01%) 18478M (-0.01%) 68842M (+0.02%) 22673M (+0.01%) 52739M (+0.00%) 16172M (-0.01%) 35665742M (-0.01%) C 00915b22ff 60988M (-0.00%) 76750M (-0.01%) 89475M (-0.00%) 18479M (+0.01%) 68826M (-0.00%) 22671M (-0.01%) 52736M (-0.01%) 16174M (+0.01%) 35668897M (-0.01%) C a4e434ebaa 60989M (+0.01%) 76759M (+0.01%) 89476M (+0.00%) 18478M (-0.00%) 68826M (+0.00%) 22673M (-0.00%) 52741M (-0.01%) 16173M (-0.02%) 35672887M (-0.01%) 9bd910dae4 C 0e4be262f4 60986M (+0.01%) 76753M (+0.00%) 89472M (-0.00%) 18479M (-0.02%) 68825M (-0.01%) 22674M (+0.00%) 52744M (+0.01%) 16176M (+0.02%) 35676793M ( +0.02% ) C f3b7710b6b 60980M (-0.01%) 76752M (+0.00%) 89476M (-0.00%) 18482M (+0.01%) 68832M (+0.01%) 22673M (+0.01%) 52737M (-0.01%) 16173M (-0.00%) 35668315M (-0.02%) C 4f90ce4e6e 60986M (-0.00%) 76750M (-0.01%) 89478M (+0.02%) 18480M (+0.03%) 68825M (+0.00%) 22672M (+0.02%) 52742M (-0.01%) 16173M (+0.00%) 35674163M (-0.00%) C d593bcdc54 60989M (+0.01%) 76755M (+0.02%) 89464M (-0.02%) 18473M (-0.02%) 68824M (-0.01%) 22668M (-0.01%) 52748M (+0.02%) 16173M (+0.01%) 35674675M (+0.02%) C e63ae7701a 60982M (-0.01%) 76739M (-0.01%) 89482M (-0.00%) 18477M (+0.02%) 68833M (+0.01%) 22670M (-0.01%) 52739M (-0.01%) 16172M (-0.00%) 35668766M (-0.01%) C cd5d07e65c 60987M (+0.00%) 76745M (+0.00%) 89486M (+0.00%) 18474M (-0.03%) 68829M (-0.00%) 22671M (+0.01%) 52746M (+0.01%) 16172M (-0.00%) 35673066M ( +0.02% ) C 35ce17b6f6 60987M (-0.01%) 76744M (-0.01%) 89485M (-0.02%) 18479M (+0.01%) 68829M (+0.00%) 22670M (-0.00%) 52743M (-0.03%) 16172M (-0.04%) 35666151M (-0.01%) C 696946f897 60991M (+0.01%) 76752M (+0.00%) 89502M (+0.03%) 18476M (+0.02%) 68826M (+0.01%) 22670M (+0.00%) 52757M (-0.02%) 16178M (+0.00%) 35669476M (+0.01%) 41079dac98 C 5d501d1a8d 60984M (-0.01%) 76751M (+0.01%) 89476M (+0.00%) 18472M (-0.03%) 68820M (-0.01%) 22670M (-0.01%) 52766M (+0.04%) 16178M (+0.03%) 35665515M (-0.01%) C 9bcf43c0f3 60990M (+0.00%) 76746M (-0.01%) 89472M (-0.01%) 18477M (+0.01%) 68828M (-0.00%) 22672M (+0.01%) 52747M (+0.01%) 16173M (-0.01%) 35669035M (-0.01%) C 524fde8a4d 60990M (+0.02%) 76751M (-0.00%) 89481M (+0.00%) 18476M (-0.01%) 68830M (+0.01%) 22670M (-0.00%) 52744M (-0.02%) 16174M (+0.00%) 35674074M (+0.00%) C 85e10cb4fe 60980M (-0.01%) 76753M (+0.01%) 89481M (-0.01%) 18478M (+0.01%) 68825M (+0.01%) 22671M (+0.01%) 52753M (-0.02%) 16174M (-0.04%) 35672648M (+0.00%) ba79486b6a C 481cf71a02 60987M (-0.00%) 76746M (-0.02%) 89489M (-0.00%) 18475M (+0.00%) 68821M (-0.01%) 22668M (+0.00%) 52761M (+0.03%) 16181M (+0.05%) 35672460M (+0.00%) C 18d6d67067 60987M (-0.00%) 76761M (+0.01%) 89489M (+0.01%) 18475M (+0.00%) 68829M (-0.01%) 22668M (-0.03%) 52748M (+0.01%) 16173M (-0.03%) 35671983M (+0.01%) 1eebd2a42e C e2ff1348f8 60989M (+0.01%) 76753M (-0.00%) 89483M (+0.01%) 18475M (-0.01%) 68836M (+0.02%) 22674M (+0.01%) 52740M (-0.03%) 16177M (+0.00%) 35668191M (-0.01%) C 7450a75b93 60981M (-0.02%) 76755M (-0.01%) 89477M (-0.01%) 18477M (-0.02%) 68821M (-0.01%) 22671M (+0.03%) 52758M (+0.00%) 16177M (-0.03%) 35672527M (+0.01%) C 7c6162fc59 60995M (+0.00%) 76760M (+0.01%) 89487M (+0.00%) 18480M (+0.01%) 68826M (-0.01%) 22665M (-0.03%) 52757M (+0.01%) 16181M (+0.03%) 35669190M (-0.00%) C 271a62f838 60994M (+0.02%) 76751M (+0.01%) 89486M (+0.00%) 18479M (-0.01%) 68835M (+0.01%) 22671M (-0.01%) 52752M (+0.00%) 16177M (-0.01%) 35670183M (-0.01%) 98df73d52a C 2b260c665c 60983M (+0.01%) 76745M (-0.01%) 89486M (+0.00%) 18480M (+0.02%) 68829M (+0.00%) 22673M (+0.01%) 52752M (+0.00%) 16179M (-0.00%) 35672299M (+0.01%) 4ecee62133 C bf017614ae 60979M (-0.02%) 76753M (+0.00%) 89482M (+0.01%) 18476M ( -0.04% ) 68828M (+0.00%) 22670M (+0.01%) 52751M (-0.03%) 16179M (+0.03%) 35667235M (-0.01%) C 5d7e0820dd 60992M (+0.00%) 76750M (+0.00%) 89477M (-0.02%) 18483M (+0.01%) 68826M (-0.02%) 22669M (-0.03%) 52769M (+0.01%) 16175M (-0.02%) 35672119M (+0.01%) d8ace2df57 C c9f13b5404 60990M (-0.00%) 76749M (-0.01%) 89493M (+0.02%) 18481M (+0.02%) 68839M (+0.02%) 22676M (+0.02%) 52763M (-0.01%) 16177M (+0.01%) 35668337M (-0.00%) C b77f7df497 60991M (+0.00%) 76755M (-0.01%) 89472M (-0.00%) 18478M (+0.00%) 68823M (-0.00%) 22671M (-0.02%) 52767M (+0.01%) 16175M (-0.01%) 35670083M (-0.00%) C b2d90d4da0 60989M (+0.01%) 76760M (+0.01%) 89475M (-0.01%) 18478M (+0.01%) 68826M (-0.00%) 22675M (+0.02%) 52763M (-0.00%) 16177M (+0.00%) 35671391M (+0.01%) C 71a77dc043 60982M (-0.02%) 76751M (-0.00%) 89484M (+0.01%) 18477M (-0.02%) 68829M (+0.00%) 22671M (-0.02%) 52764M (+0.01%) 16177M (-0.04%) 35666910M (-0.01%) C 9a02a3c7f4 60991M (+0.01%) 76754M (+0.01%) 89472M (-0.01%) 18480M (+0.01%) 68826M (-0.01%) 22675M (+0.01%) 52758M (-0.01%) 16182M (+0.02%) 35671086M (-0.00%) f7e7132c8e C e8753c0de9 60983M (-0.00%) 76749M (-0.01%) 89477M (+0.00%) 18479M (+0.01%) 68834M (+0.02%) 22673M (+0.00%) 52765M (+0.00%) 16179M (+0.01%) 35671569M (+0.01%) d826f1af7e C 853a8b4f33 60983M (-0.03%) 76756M (+0.01%) 89473M (-0.01%) 18477M (+0.01%) 68821M (-0.00%) 22673M (-0.01%) 52764M (+0.01%) 16178M (+0.01%) 35667018M (-0.02%) C 91f7e7f592 61000M (+0.02%) 76748M (-0.01%) 89481M (-0.01%) 18476M (-0.01%) 68823M (-0.00%) 22674M (+0.02%) 52759M (-0.00%) 16177M (-0.02%) 35673844M (+0.02%) C 85bb71090c 60990M (-0.01%) 76754M (+0.01%) 89490M (+0.01%) 18477M (+0.00%) 68826M (-0.00%) 22671M (+0.00%) 52761M (-0.01%) 16179M (+0.01%) 35668253M (+0.00%) C 13055d60bb 60994M (-0.01%) 76744M (+0.00%) 89476M (-0.00%) 18477M (+0.01%) 68829M (+0.00%) 22670M (-0.01%) 52764M (-0.00%) 16178M (+0.01%) 35666849M (-0.01%) C 46d9d4b2e0 61000M (+0.01%) 76743M (-0.01%) 89477M (-0.01%) 18475M (-0.02%) 68827M (-0.00%) 22671M (+0.01%) 52765M (+0.04%) 16177M (+0.02%) 35671389M (+0.01%) b8892b9a9b C ef0682d3e6 60991M (-0.01%) 76748M (-0.01%) 89481M (+0.01%) 18477M (+0.01%) 68828M (-0.01%) 22670M (-0.01%) 52746M (-0.01%) 16174M (-0.00%) 35668523M (-0.01%) C 25663df7a6 60995M (+0.00%) 76755M (+0.00%) 89476M (+0.00%) 18475M (-0.03%) 68832M (+0.01%) 22672M (-0.00%) 52751M (+0.02%) 16174M (-0.01%) 35671871M (-0.01%) C 29c15eeff7 60992M (-0.01%) 76754M (+0.00%) 89473M (-0.01%) 18481M (+0.02%) 68828M (+0.00%) 22673M (+0.00%) 52743M (-0.01%) 16176M (+0.02%) 35674328M ( +0.02% ) C 65ba5276e7 60996M (-0.00%) 76754M (+0.00%) 89478M (+0.00%) 18478M (-0.02%) 68827M (+0.01%) 22672M (-0.01%) 52749M (+0.01%) 16173M (-0.02%) 35665721M ( -0.03% ) C 43b8bc4b6f 60998M (+0.02%) 76752M (+0.00%) 89474M (-0.01%) 18482M (+0.02%) 68824M (+0.00%) 22675M (+0.02%) 52742M (-0.00%) 16176M (+0.01%) 35675392M (-0.00%) C c9faf8da5e 60988M (-0.02%) 76748M (-0.00%) 89479M (+0.00%) 18478M (-0.00%) 68823M (-0.02%) 22671M (-0.02%) 52743M (+0.01%) 16174M (+0.00%) 35676189M (+0.02%) C 2723e9aad0 61002M (+0.01%) 76750M (-0.01%) 89476M (-0.01%) 18479M (+0.02%) 68835M (+0.01%) 22675M (+0.02%) 52740M (-0.02%) 16174M (+0.00%) 35669514M (-0.01%) 79c11ef40c C e720636120 60994M (-0.01%) 76754M (+0.01%) 89484M (+0.00%) 18475M (-0.01%) 68828M (+0.00%) 22671M (-0.02%) 52749M (+0.01%) 16174M (-0.00%) 35671893M (+0.01%) a3f395484b C 38f1488ecd 60998M (-0.00%) 76748M (-0.02%) 89481M (-0.00%) 18477M (+0.01%) 68825M (-0.01%) 22674M (+0.01%) 52745M (-0.01%) 16175M (+0.01%) 35669886M (-0.00%) C 5eccfaec2d 60999M (-0.01%) 76761M (+0.01%) 89483M (+0.00%) 18476M (-0.02%) 68829M (-0.01%) 22672M (+0.00%) 52752M (+0.00%) 16173M (-0.01%) 35670419M (-0.00%) C b4604e8cef 61007M (+0.02%) 76754M (+0.02%) 89483M (-0.00%) 18480M (+0.02%) 68836M (+0.01%) 22671M (+0.01%) 52751M (+0.01%) 16174M (-0.03%) 35671761M (+0.00%) 0a48ff2a7f C 1600b05fda 60993M (-0.02%) 76739M (-0.01%) 89485M (+0.01%) 18477M (-0.02%) 68828M (-0.00%) 22669M (-0.02%) 52748M (+0.00%) 16179M (+0.01%) 35670387M (-0.01%) f8629b2036 C 589851cbbf 61002M (+0.02%) 76747M (-0.00%) 89476M (-0.01%) 18480M (+0.02%) 68829M (+0.01%) 22674M (+0.02%) 52747M (+0.01%) 16177M (-0.01%) 35673607M (+0.02%) 6c35a89dc6 C fea69aa19f 60992M (-0.00%) 76747M (-0.00%) 89482M (-0.00%) 18477M (-0.00%) 68825M (-0.00%) 22670M (-0.02%) 52743M (-0.04%) 16179M (-0.01%) 35668109M (+0.01%) C 0727fcb11d 60995M (+0.01%) 76748M (-0.01%) 89484M (+0.00%) 18477M (-0.01%) 68828M (+0.01%) 22675M (+0.03%) 52762M (+0.01%) 16181M (+0.03%) 35665700M (-0.02%) C 26fdd8faff 60991M (-0.01%) 76757M (+0.01%) 89481M (-0.01%) 18479M (+0.02%) 68823M (-0.01%) 22668M (-0.02%) 52758M (+0.00%) 16176M (+0.01%) 35672314M (+0.01%) 8a7d8c1690 C e971c3ee0e 60998M (+0.02%) 76746M (-0.01%) 89489M (+0.02%) 18476M (+0.00%) 68827M (-0.02%) 22673M (+0.02%) 52757M (+0.01%) 16175M (-0.02%) 35667971M (-0.00%) C 597ffbe09d 60988M (-0.01%) 76751M (+0.00%) 89474M (-0.00%) 18476M (-0.01%) 68838M (+0.02%) 22668M (-0.02%) 52753M (-0.05%) 16178M (+0.04%) 35669612M ( +0.03% ) C 632a557f31 60994M (+0.01%) 76750M (-0.01%) 89477M (-0.00%) 18477M (-0.02%) 68826M (+0.01%) 22672M (-0.00%) 52777M (+0.01%) 16171M (-0.01%) 35660281M (-0.00%) C 8b09e47e6f 60986M (-0.02%) 76755M (+0.01%) 89481M (+0.01%) 18482M (+0.03%) 68821M (-0.01%) 22672M (+0.02%) 52774M (+0.02%) 16173M (+0.01%) 35661772M ( -0.03% ) C e21fcc2e18 61000M (+0.01%) 76747M (-0.00%) 89474M (-0.01%) 18476M (+0.00%) 68829M (-0.02%) 22667M (-0.02%) 52764M (+0.01%) 16172M (-0.02%) 35671736M ( +0.02% ) C 5e78d5e262 60996M (+0.01%) 76750M (+0.00%) 89487M (+0.01%) 18475M (+0.00%) 68840M (+0.02%) 22672M (-0.01%) 52758M (-0.02%) 16175M (+0.02%) 35664348M (-0.00%) C a96cda0e33 60989M (-0.00%) 76750M (+0.00%) 89479M (+0.01%) 18475M (-0.01%) 68825M (+0.00%) 22674M (+0.03%) 52770M ( +0.06% ) 16171M (-0.04%) 35665279M (+0.01%) C f223ebfc2b 60990M (-0.01%) 76749M (+0.00%) 89468M (-0.00%) 18477M (+0.00%) 68822M (-0.00%) 22666M (-0.03%) 52736M (-0.00%) 16178M (-0.00%) 35661806M (+0.00%) 9f203509ce C cd81aae57a 60998M (+0.03%) 76748M (-0.01%) 89469M (-0.01%) 18476M (+0.00%) 68824M (+0.00%) 22673M (-0.00%) 52737M (-0.01%) 16178M (+0.00%) 35661427M (+0.01%) acb78bde6f C 480af73916 60982M ( -0.04% ) 76752M (+0.01%) 89476M (+0.01%) 18476M (+0.00%) 68821M (-0.01%) 22673M (+0.01%) 52745M (+0.01%) 16178M (+0.02%) 35659427M (-0.01%) C 79069ce86d 61008M (+0.02%) 76746M (-0.00%) 89471M (-0.00%) 18475M (-0.03%) 68825M (+0.01%) 22672M (-0.00%) 52740M (-0.01%) 16174M (-0.01%) 35662423M (-0.00%) C c11df52f9b 60993M (+0.02%) 76749M (-0.01%) 89472M (-0.01%) 18480M (+0.01%) 68821M (-0.02%) 22673M (+0.01%) 52743M (+0.01%) 16176M (-0.00%) 35664118M ( -0.03% ) C ae29bfd9db 60983M (-0.02%) 76756M (-0.00%) 89482M (+0.01%) 18479M (+0.03%) 68834M (+0.01%) 22671M (+0.00%) 52740M (-0.00%) 16176M (+0.01%) 35675038M ( +0.03% ) C 85b90f560d 60995M (+0.00%) 76758M (+0.01%) 89477M (-0.01%) 18474M (-0.00%) 68825M (+0.00%) 22670M (+0.01%) 52741M (-0.03%) 16174M (-0.03%) 35663852M (+0.01%) C 54840055b8 60995M (-0.00%) 76748M (-0.01%) 89482M (+0.00%) 18474M (-0.02%) 68823M (-0.01%) 22669M (+0.00%) 52755M (+0.00%) 16180M (+0.02%) 35661248M ( -0.02% ) C 719006a195 60996M (+0.01%) 76752M (+0.01%) 89482M (-0.01%) 18479M (+0.01%) 68829M (+0.01%) 22668M (-0.01%) 52753M (+0.01%) 16176M (+0.06%) 35668252M (+0.02%) C eef8e79e3a 60992M (+0.00%) 76742M (-0.02%) 89494M (+0.01%) 18477M (+0.02%) 68823M (+0.00%) 22670M (-0.00%) 52748M (+0.01%) 16167M (-0.00%) 35661731M (+0.00%) C 25976e8360 60991M (-0.00%) 76755M (+0.00%) 89482M (+0.00%) 18474M (+0.02%) 68822M (+0.00%) 22670M (+0.01%) 52744M (+0.00%) 16167M (+0.00%) 35660240M (+0.01%) 51e0248aef C 4a8a0593bd 60993M (-0.00%) 76754M (+0.01%) 89480M (-0.01%) 18471M (-0.03%) 68822M (-0.01%) 22668M (+0.00%) 52741M (-0.01%) 16166M (-0.01%) 35657914M (-0.01%) C 1117d2a35f 60995M (+0.00%) 76744M (-0.01%) 89490M (+0.01%) 18477M (-0.00%) 68826M (+0.00%) 22668M (-0.01%) 52747M (+0.01%) 16167M (-0.01%) 35662560M (+0.01%) C 42368f9194 60995M (-0.01%) 76751M (-0.00%) 89481M (+0.01%) 18478M (+0.01%) 68824M (+0.00%) 22671M (+0.01%) 52740M (-0.01%) 16169M (+0.01%) 35658424M (-0.00%) d6d8622f12 C a5fcd840e7 61002M (+0.01%) 76751M (+0.00%) 89473M (-0.00%) 18476M (-0.01%) 68820M (-0.02%) 22668M (-0.01%) 52747M (+0.01%) 16167M (-0.01%) 35659740M (+0.01%) C 33c4e3e2bc 60996M (+0.01%) 76749M (+0.00%) 89478M (-0.00%) 18477M (+0.01%) 68834M (+0.01%) 22672M (+0.01%) 52743M (+0.00%) 16168M (+0.00%) 35655964M (-0.01%) 4f1ab334a4 C bac9b7a387 60989M (-0.00%) 76747M (-0.01%) 89480M (+0.00%) 18476M (+0.00%) 68828M (+0.00%) 22669M (-0.02%) 52742M (-0.02%) 16167M (-0.02%) 35658042M (-0.01%) C df3629dc0c 60991M (-0.01%) 76755M (+0.01%) 89479M (-0.00%) 18475M (-0.01%) 68825M (-0.01%) 22674M (+0.00%) 52753M (+0.02%) 16170M (-0.01%) 35663196M (+0.01%) ac508575ed C 2ff56633b9 60998M (-0.00%) 76750M (-0.01%) 89482M (+0.01%) 18477M (+0.02%) 68834M (+0.01%) 22674M (+0.02%) 52744M (+0.00%) 16171M (-0.01%) 35658594M (-0.00%) C 5c3f02cbb3 60999M (+0.01%) 76760M (+0.01%) 89477M (-0.02%) 18474M (-0.01%) 68825M (-0.00%) 22670M (+0.00%) 52741M (-0.00%) 16173M (+0.02%) 35660021M (+0.01%) C b6212a4caf 60991M (-0.00%) 76751M (-0.00%) 89493M (+0.02%) 18476M (+0.01%) 68828M (+0.01%) 22669M (-0.02%) 52742M (-0.01%) 16170M (+0.01%) 35656370M (-0.01%) C 471b7b79ee 60992M (-0.01%) 76751M (+0.01%) 89473M (-0.01%) 18473M (-0.02%) 68825M (-0.00%) 22673M (+0.01%) 52747M (+0.01%) 16169M (+0.00%) 35661703M (+0.01%) C 8cfa36d190 60997M (+0.02%) 76743M (-0.01%) 89480M (-0.01%) 18477M (+0.02%) 68827M (-0.00%) 22672M (+0.02%) 52744M (-0.03%) 16169M (-0.04%) 35659488M (+0.01%) 75dd5b3df2 C 690d94b7bd 60987M (-0.01%) 76752M (+0.00%) 89489M (+0.02%) 18473M (-0.01%) 68830M (+0.01%) 22667M (-0.00%) 52762M (+0.01%) 16176M (+0.02%) 35655295M (-0.02%) C 6ca6a328ae 60995M ( -0.05% ) 76751M (+0.01%) 89475M (-0.02%) 18475M (+0.00%) 68824M (-0.03%) 22667M (-0.01%) 52757M (+0.03%) 16173M (+0.01%) 35660690M (+0.01%) C e927f4bbf4 61024M (+0.00%) 76745M (-0.00%) 89489M (+0.00%) 18474M (+0.00%) 68841M (+0.02%) 22671M (+0.01%) 52742M (-0.01%) 16173M (+0.02%) 35658486M (-0.00%) 54a1e05d3c C 37e3af835e 61024M (+0.02%) 76746M (-0.00%) 89488M (-0.00%) 18473M (-0.01%) 68830M (-0.01%) 22669M (+0.01%) 52747M (-0.00%) 16170M (-0.01%) 35659822M (+0.01%) c0da62a49f C 17e226f71e 61014M (-0.01%) 76749M (-0.00%) 89490M (-0.00%) 18475M (-0.02%) 68837M (+0.01%) 22667M (-0.02%) 52747M (+0.01%) 16171M (+0.00%) 35657466M (+0.01%) 964f9c0754 C ceb2365a20 61023M (-0.00%) 76752M (+0.00%) 89490M (+0.00%) 18478M (+0.03%) 68830M (-0.01%) 22671M (+0.01%) 52742M (+0.00%) 16171M (-0.00%) 35654695M (+0.00%) C e5473760bb 61024M (+0.01%) 76750M (+0.00%) 89490M (+0.00%) 18473M (-0.02%) 68837M (-0.00%) 22668M (-0.01%) 52740M (-0.01%) 16171M (+0.00%) 35654293M ( -0.02% ) C 55a9855be5 61020M (+0.00%) 76746M (-0.01%) 89488M (-0.01%) 18476M (-0.00%) 68837M (+0.00%) 22669M (+0.00%) 52744M (-0.00%) 16171M (-0.03%) 35661450M (+0.00%) C dcef308ecc 61019M (+0.02%) 76753M (+0.01%) 89493M (+0.01%) 18476M (+0.00%) 68835M (-0.01%) 22669M (-0.02%) 52746M (+0.00%) 16176M (+0.01%) 35661125M (-0.01%) b3d25f59d5 C 7df0826c41 61007M (-0.02%) 76747M (-0.01%) 89484M (-0.01%) 18476M (-0.01%) 68843M (+0.00%) 22672M (+0.02%) 52746M (+0.00%) 16174M (+0.00%) 35663982M (+0.01%) C 121a9c414f 61020M (-0.00%) 76756M (+0.01%) 89489M (+0.01%) 18478M (+0.00%) 68840M (-0.01%) 22668M (+0.00%) 52743M (-0.01%) 16174M (+0.02%) 35658995M (+0.01%) 4c61843e44 C b5a5276ca7 61022M (+0.02%) 76748M (-0.00%) 89483M (+0.00%) 18477M (+0.00%) 68844M (+0.02%) 22668M (+0.01%) 52751M (+0.00%) 16170M (-0.01%) 35655735M (-0.00%) ec7ab6fb7b C 327d6e1f97 61010M (-0.02%) 76752M (-0.00%) 89482M (+0.00%) 18476M (+0.00%) 68831M (-0.00%) 22665M (-0.01%) 52749M (+0.02%) 16171M (+0.01%) 35656252M (-0.00%) C 9e1a185be4 61023M (+0.00%) 76752M (+0.00%) 89482M (-0.01%) 18475M (-0.00%) 68834M (+0.00%) 22667M (-0.00%) 52738M (-0.05%) 16170M (-0.00%) 35657114M (+0.00%) C 8aebfcd953 61023M (+0.00%) 76748M (-0.01%) 89493M (+0.02%) 18476M (-0.02%) 68831M (-0.01%) 22668M (-0.00%) 52763M (-0.01%) 16171M (-0.00%) 35656968M (-0.00%) 4996e3be34 C c722ef4874 61022M (+0.01%) 76754M (-0.00%) 89478M (-0.00%) 18479M (+0.03%) 68834M (-0.00%) 22668M (+0.00%) 52767M (+0.02%) 16171M (+0.01%) 35657386M (-0.01%) C edab1925d8 61019M (+0.01%) 76754M (-0.00%) 89481M (-0.00%) 18473M (-0.00%) 68837M (+0.00%) 22668M (+0.01%) 52756M (-0.01%) 16170M (-0.02%) 35659911M (+0.01%) e486a26b9c C a095db2f0b 61010M (-0.02%) 76756M (+0.01%) 89485M (+0.01%) 18473M (-0.00%) 68835M (-0.01%) 22666M (+0.00%) 52761M (+0.01%) 16174M (+0.02%) 35657087M (-0.01%) 0d6f65160a C 77b8b33b5a 61022M (-0.00%) 76751M (-0.01%) 89473M (-0.02%) 18474M (-0.01%) 68841M (+0.00%) 22666M (-0.03%) 52758M (+0.02%) 16171M (+0.00%) 35658921M (-0.00%) 475f022cb7 C ff94a19f5c 61023M (+0.00%) 76760M (+0.01%) 89494M (+0.01%) 18476M (+0.01%) 68839M (+0.01%) 22672M (+0.03%) 52746M (-0.00%) 16171M (+0.02%) 35659707M (-0.01%) C 3c51ed9870 61020M (+0.01%) 76754M (-0.00%) 89482M (+0.00%) 18474M (-0.01%) 68832M (+0.00%) 22666M (-0.02%) 52748M (-0.02%) 16168M ( -0.08% ) 35664312M ( +0.02% ) C 89c8a253d7 61016M (+0.02%) 76758M (+0.01%) 89481M (-0.00%) 18476M (+0.01%) 68831M (-0.02%) 22669M (+0.00%) 52758M (-0.03%) 16180M (+0.00%) 35655926M (+0.00%) 6f5c214928 C 5c4324326d 61003M (-0.03%) 76750M (-0.02%) 89484M (+0.01%) 18475M (+0.02%) 68842M (+0.01%) 22669M (-0.01%) 52773M (+0.04%) 16180M (-0.01%) 35654539M (-0.02%) C 8f58ce2d02 61019M (-0.00%) 76762M (+0.02%) 89478M (+0.01%) 18472M (-0.01%) 68834M (-0.01%) 22672M (+0	2026-01-13T08:49:47
https://docs.suprsend.com/changelog?_gl=112fhh1c_gcl_auMTk4MjY1MzcwOC4xNzM3MjcwMDQwLjE2MTg0OTAwOC4xNzQyNDY0NTg3LjE3NDI0NjQ1ODY._gaMTEwNDU5MzYxMC4xNzI5NDkxODI3_ga_PPDYBESP2L*MTc0MjYzMDUxMC4yMDguMS4xNzQyNjMwNjM2LjIuMC4w#hosted-preference-page-%E2%80%94-modern-design-with-multi-language-support	Product Updates - SuprSend, Notification infrastructure for Product teams Skip to main content SuprSend, Notification infrastructure for Product teams home page Search... ⌘ K Community Trust Center Platform Status Postman Collection Changelog Product Updates Contact Us Get Started SuprSend, Notification infrastructure for Product teams home page Search... ⌘ K Ask AI Contact Us Get Started Get Started Search... Navigation Changelog Product Updates Documentation API Reference Management API CLI Reference Developer Resources Changelog Documentation API Reference Management API CLI Reference Developer Resources Changelog Changelog Product Updates OpenAI Open in ChatGPT Logs of all the feature releases, improvements, and bug fixes in SuprSend. OpenAI Open in ChatGPT 18 December 2025 Hosted Preference Page — Modern Design with Multi-Language Support The hosted preference page has been updated with a refreshed UI and locale-aware localization support. Static UI content (CTAs, labels, system text) is translated automatically using built-in i18n support for up to 23 languages. Dynamic content, including notification category names and descriptions, is rendered using the translation files configured by you, based on the user’s locale. 📘 Checkout hosted preference page documentation and see how translations work 3 December 2025 Category Translations for Preference Centers Reach users worldwide with category translations — show your preference centers in your users’ native language. Whether your users speak Spanish, French, German, or any other language, they’ll see category names and descriptions in their preferred locale, making it easier for them to understand and manage their notification preferences. What you get: Multi-language support : Upload translations via Dashboard, API, or CLI — choose the method that works best for your workflow Smart fallbacks : If a translation isn’t available for a specific locale (e.g., es-AR ), we automatically try the base locale ( es ), then fall back to English — your users always see something meaningful Zero maintenance : English translations are automatically generated from your category names and descriptions, so you don’t need to manage them separately 📘 Learn more in the category translations documentation . 1 December 2025 📚 S3 Connector v2.0 — Comprehensive Notification Data Export S3 Connector v2.0 exports end-to-end notification data to your S3 bucket, giving you full visibility into requests, workflows, and message delivery for analytics, debugging, and compliance. It replaces the limited v1.0 connector with complete, structured logging. S3 Connector v1.0 will be deprecated over time. Migrate to v2.0 to access full logs and notification analytics. What’s New We’ve added 3 data points for end-to-end traceability of notifications from API request → workflow execution → final delivery : Messages: Delivery status, engagement metrics, vendor responses, and failures Workflow Executions: Step-by-step workflow logs for debugging conditions, preferences, and errors Requests: API payloads and responses for trigger-level debugging and audit trails Use Cases Internal analytics or customer-facing analytics Debug delivery and workflow issues using detailed logs or show logs on your customer portal Maintain audit trails for compliance and internal reporting Query and analyze notification data you fully own 📘 Check out the S3 Connector v2.0 documentation for more details. 29 November 2025 Channel-Level Control for Preference Categories Choose which channels users are opted into by default when setting up preference categories. You can use this to have preference category defaults as user gets in-app notification by default and other channels will be sent only if user explicitly opts in to them. 📘 Learn more in the preference categories documentation . 31 October 2025 Type-Safe Workflow Triggers Catch payload errors at compile time and get IDE autocomplete for workflow payloads and event properties using generated type definitions. Define your payload structure once using SuprSend JSON schemas , and automatically generate type definitions using SuprSend CLI . What’s Included and Why This Matters Prevents production bugs caused by invalid payloads Keeps backend code and notification schemas in sync Get IDE autocomplete, inline validation, and type hints for payload fields Supported languages: TypeScript, Python, Go, Java, Kotlin, Swift, Dart 📘 Learn more in the type safety & type generation documentation . 30 October 2025 🌍 Translations - One template, all languages, zero hassle Go global with translations — the easiest way to localize your notifications. One template, multiple languages, automatic fallbacks. No more maintaining separate templates for each language. What You Can Do Localize notifications instantly: Smart translation keys → Use {{t "key"}} syntax in templates and let SuprSend handle the rest Automatic fallbacks → Users always get a translation, even if their exact locale isn’t available Dynamic content → Pass variables like {{t "key" name=user.first_name}} for personalized content Pluralization → Automatic handling of singular/plural forms based on count Manage translations like code: Upload, download, edit → Work with translation files locally or in the dashboard Version control → Complete history tracking with one-click rollbacks CLI & API support → Manage translations programmatically or via command line Built for developers: Namespaced keys → {{t "feature:key"}} to avoid conflicts across features JSONNET support → Complex conditional logic for advanced use cases Handlebars integration → Combine with other helpers for dynamic content Version control for translations → Track changes, maintain history, and roll back when needed 📘 Check out the translation documentation to get started. 1 October 2025 Preference Category Management APIs You can now programmatically create, update, and commit preference categories using the Management APIs — no dashboard required. This makes it easy to integrate category management into your existing workflows, scripts, and deployment pipelines. 👉 Also available via the SuprSend CLI . 📘 See the API documentation to get started. 29 September 2025 🚀 SuprSend CLI Beta - Ship Notification changes like code We’re excited to announce the public beta of SuprSend CLI , bringing full notification management to your terminal. Using CLI, you can manage and promote assets across workspaces, integrate with CI/CD, and treat notification changes just like code. What You Can Do Promote assets across workspaces — move workflows, schemas, events, and categories between environments (e.g., staging → production) with suprsend sync or targeted pull/push commands. Automate with CI/CD Deployment – Release notification changes through feature or bugfix branches, just like any other piece of code: version it, test it, and deploy it. Manage notification changes in Git — pull assets locally, version them alongside your application code, and push updates as feature branches or bugfix releases. Treat notification infrastructure just like code — review, branch, merge, and release with the same version control workflows you already use. Built for developers Code reviews for notifications — keep your notification infrastructure in Git, track changes, and roll back when needed. Approval gates for production — ensure no change goes live without review and approval. Work with assets locally — create, edit, and test workflows, schemas, and translation files on your machine. Version control & rollback — maintain change log and safely revert changes when required. This is a beta release — we’re actively gathering feedback and making improvements. So, feel free to report an issue and contribute to the project. 📘 Check out the CLI documentation to get started. 29 September 2025 🤖 SuprSend MCP Server (Beta) — AI-Powered Notification Management Your AI agents, copilots, and LLM tools can now directly interact with SuprSend through natural language, making notification management as simple as having a conversation. What You Can Do with SuprSend MCP Everyday workflows with AI: Trigger workflows on demand “Run the approval-required workflow for user John Doe to test my setup.” Bootstrap test data “Create a sample user named John Doe and a tenant called acme-corp in my workspace.” Manage preferences “Enable email notifications for marketing and disable SMS.” Configure branding “Update the logo and primary color for the enterprise tenant.” Vibe-code with AI: Ask AI to fetch setup guides, code examples, or integration snippets directly from SuprSend docs and apply it in your application code. Expose safe, scoped endpoints (via MCP) that wrap APIs with context, reducing guesswork and hallucinations. Integrate with LLM-based assistants (Claude, Copilot, Cursor, Windsurf, etc.) to simplify notification setup with SuprSend. Compatible AI Tools Works with Claude, Cursor, Windsurf, and any MCP-compatible AI agent. Notes & Caveats (Beta) - APIs, behavior, or scopes may change based on feedback. We restrict destructive operations (e.g. deletes) initially to reduce risk. We welcome your feedback — report issues and share feedback to help us harden MCP for production. Getting Started Start the MCP server and configure it with your AI tool. See our MCP setup guide for detailed instructions. 12 September 2025 Send Notifications Only to Verified Channels in Sandbox Sandbox workspaces come pre-configured with SuprSend vendors for quick testing. However, we noticed some cases of misuse where test messages were being sent to unintended recipients. To prevent accidental spam and keep Sandbox safe, notifications can now only be sent to verified channels . You can set upto 5 verified channels for each channel type. Reach out to us if you need more. You can add and manage your verified channels from developers -> Verified Channels page . 12 September 2025 Test Mode: Test Notifications safely without sending to real users Testing notifications shouldn’t mean worrying about accidentally pinging your customers. In most companies, teams end up redirecting notifications to shared inboxes like [email protected] or [email protected] just to avoid delivery to real users—while still being able to debug the full notification flow. With Test Mode , you can now replicate this real-world testing flow directly in our platform: Test end-to-end notification flow : Add channels belonging to internal testers as test channels. In test mode, notifications to these channels are delivered normally—so you can preview messages on real devices. Set Up Test Channels : You can add channels belonging to your internal testers as test channels. Delivery will not be blocked for test channels in test mode. This helps you see preview of the notification in your real device. Catch-All Routing : Redirect all non-test notifications to a common channel (e.g., a QA inbox), making it easy to trace and debug every message in one place. This ensures you can confidently test notification workflows in an environment that mirrors production—without the risk of real users getting test messages. 30 August 2025 Validate workflow trigger Payload using JSON Schema We’ve introduced API-level JSON Schema validation for workflow trigger payloads. This catches payload mismatches before execution, preventing runtime failures and ensuring consistent, correct notifications. Why it matters When you trigger a workflow, you pass data (payload) that is used to resolve workflow variables and populate dynamic content in templates. Currently, If the payload does not include all the variables expected in the workflow, the execution may fail at different stages. With this change, Validation will happen at API level and there’ll be: Fewer runtime failures : Stop workflows from starting with missing or malformed data. Faster debugging : Get a clear, structured error list at request time—no more hunting through multi-step logs. More reliable messaging : Prevent partial runs, inconsistent behavior, and incorrect or incomplete notifications. How it works You can add JSON schema from Schema page and then link it to the workflow Trigger step or trigger Event from events page . When you trigger a workflow, the payload is validated against a JSON Schema that describes the expected data used to resolve variables and populate dynamic content. If the payload doesn’t match the schema, the Trigger API returns error response with a list of validation errors (e.g., path, expected type, missing fields). If validation passes, the workflow proceeds as usual. Fixes and Improvements: Workflow slug validation at the API layer: If a referenced workflow slug isn’t available, the error is now returned directly in the API response (in addition to request logs) for faster debugging. This validation will only apply to new workflows created after this change. If you want to apply it all your existing workflows, reach out to SuprSend support. 23 August 2025 Tenancy social links update Added support for TikTok in tenant social_links . Twitter renamed to x in descriptions and examples (field name remains compatible as per API changes). Updated social link icons for better visual consistency. 19 August 2025 Message logs revamp Redesigned UI for seamless tracking of notification lifecycles. Quickly view delivery status, opens, clicks, and errors across all channels in a single log view. Entity-level visibility : Drill down into logs by workflow, user, object, or list to understand exactly what happened in context. Advanced filtering : Filter logs by status, workflow, template, channel, category, or time range to debug faster. Consistent date range filter across all log pages, making it easier to trace the journey of a notification from request → workflow → final message delivery and it’s interaction state. Fixes and Improvements react-sdk (v0.3.0) - Introduced a custom infinite-scroll component with robust Shadow DOM compatibility. web-components (v0.3.0) - Enhanced Shadow DOM rendering support to ensure component isolation and consistent styling. 16 August 2025 Analytics 2.0 - faster, real-time, with one click filters to drill down into insights Real-time insights → Trends update as messages go out. Track performance across channels and spot dips in engagement instantly. Workflow-level comparisons → Compare workflows, templates, channels, and categories side by side to spot under performers and validate experiments. Know when your users opt-out → See which channels/categories drive opt-outs so you can adjust before churn sets in. Over-messaging trends → Track avg notifications per user, find patterns by category, and identify fatigue triggers to keep communications helpful—not noisy. Granular filtering → Multi-select filters for workflow, tenant, template, channel, category, time range Centralized error tracking → All API, workflow, and provider delivery errors in one place. Filter by tenant/workflow/template/channel, open the exact log, and debug in seconds. 23 July 2025 Sendgrid IP Pool support Enabled creation and management of SendGrid IP Pools, allowing granular control over email delivery, IP reputation, and segmentation of email traffic base on notification category. Fixes and Improvements Added support to send slack messages using broadcast. 11 July 2025 Workflow Management APIs Released comprehensive Management APIs to programmatically create, update, and commit workflows. Supports dynamic workflow orchestration — from your platform or third-party systems — to automate creation and modification of workflows from your codebase. You can checkout the documentation here . 4 July 2025 Proxy support in Java SDK Java SDK can now route outbound requests through HTTP/S proxies, enabling deployments behind corporate firewalls and network controls. 16 June 2025 iOS Native SDK Revamp with JWT based authentication & Preferences support The new iOS SDK now has our latest JWT authentication. You can use it to: JWT-based auth for secure event ingestion, profile updates and push token management. Support to add In-app Preferences Center in mobile apps with UI and example code available for quick setup. Fixes and Improvements Flutter sdk released (v2.5.0) - Fixed an Android push client issue and added silent push support for background updates. 22 May 2025 Role based auth in AWS SNS In line with our ongoing efforts to enhance platform security, we’ve also enabled IAM Role- based auth in AWS SNS vendor. Previously, authentication required creating an IAM User and sharing long-term access keys. With IAM Role-based auth , you can grant temporary, scoped access without exposing sensitive credentials. 13 May 2025 New SMS Vendor: Bird We’ve added support for sending SMS using the new Bird APIs. The setup is straightforward with a simple vendor form to fill to get started, and full integration details are available here. 30 Apr 2025 SuprSend tracked Properties Now Available in Recipients Payload Recipient payloads now include key internal properties—like user type and their unique identifier—making them readily accessible for use in templates and workflows. → For users: {“$type”: “user”, “distinct_id”: “xxxx”} → For objects: {“$type”: “object”, “object_type”: “xxx”, “id”: “xxx”}" Use these properties to pre-fill form values, add conditional branching based on user type, or Create dynamic links using unique user IDs 23 Apr 2025 Workflow Conditions - Array Comparison Operators Now, find an element in array or find intersections between two arrays in workflow conditions. Example Use cases: Send a notification to users whose role is one of ["admin","manager"] Notify tournament followers who have subscribed to any of the playing teams or players. 15 Apr 2025 Introducing Preference Tags Filter notification categories shown to users based on tags like role, team, or department—so Finance sees billing alerts, and Engineers see only error and anomaly categories. You can assign multiple tags to each preference category or section, and define complex logical expressions (e.g. role == “manager” && department in [“sales”, “marketing”]) to dynamically show relevant preference categories per user. Great for building clean, personalized preference centers without bloating the UI. 7 Apr 2025 Documentation Revamp–Cleaner, Smarter, More Interactive We’ve overhauled our documentation experience to make it more consistent, intelligent, and user-friendly: Brand-Aligned UI : The docs now match the look and feel of the SuprSend platform. AI-Powered Search : Get smarter, faster answers with AI-supported search. You can also open documentation directly in ChatGPT or Claude for conversational, AI-driven assistance. Improved Readability : Upgraded UI components provide a cleaner layout and better readability, helping you navigate and understand complex topics more easily. Interactive API Reference : Try out API requests directly from the docs and view live responses in real-time—no need to switch tools. This revamp is part of our ongoing effort to make implementation faster, smoother, and more intuitive for developers. 27 Mar 2025 Cross Lookup User Subscriptions Easily view all of a user’s subscriptions—whether to lists or objects —in one place. The Subscriptions tab on the user details page now provides a centralized view for easier access to user subscriptions. Fixes in workflows UI Resolved an issue where newly published workflow versions wouldn’t appear without a page refresh (introduced after version history was added). Fixed a bug in the test trigger modal where object suggestions incorrectly appeared when switching from API to event trigger. Removed the success metric from delivery nodes where it’s not relevant (except for Smart Delivery Nodes). 20 Mar 2025 Workflow Trigger Overrides Event-Based triggers now support overriding the actor, recipient, tenant, and object—directly within the workflow. This removes the need to resolve recipients in your code, allowing you to pass internal events as-is and dynamically resolve users and related context per workflow. Perfect for use cases like sending a daily digest to tenant admins or notifying internal account managers at a parent company—all from the same event trigger. 15 Mar 2025 Clone content across template versions and languages Editing multi-lingual templates or doing A/B with different template content? Now, rollback to a version or copy designs between different languages by cloning within template. Fixes and Improvements iOS Integration - Fixed the bitcode issue in xcode16 6 Mar 2025 Role based auth in AWS SES and S3 connector In line with our ongoing efforts to enhance platform security, we’ve now enabled IAM Role- based auth in AWS connectors. Previously, authentication required creating an IAM User and sharing long-term access keys. With IAM Role-based auth , you can grant temporary, scoped access without exposing sensitive credentials. Fixes and Improvements Added API name filter in request logs. This will help you drill down logs based on event and workflow name. 27 Feb 2025 In-App Inbox: French translation support The Inbox UI now supports automatic French translation! Just pass language="fr" when initializing the Inbox, and all static content will render in French—no extra setup needed. Available in @suprsend/web-inbox  ≥ v0.6.0. More languages coming soon Fixes and Improvements Released suprsend-py-sdk==0.13.0 with latest user and object management APIs. Fixed Email issue where tenant button was not showing cursor clickable on hover. 20 Feb 2025 In-App: Fetch cross tenant feed We’ve recently been hearing multi-tenant use cases where a user belong to multiple tenants and would want to see Inbox feed for all tenants in a single product. e.g., an account manager is handling multiple client accounts and need to see updates or daily reports linked to all their accounts in a single feed. You can now achieve this by passing tenantId = * while initializing the Inbox. SuprSendInbox Copy Ask AI interface ISuprSendInbox { workspaceKey : string distinctId : string \| null subscriberId : string \| null tenantId ?: "*" ... } 15 Feb 2025 Workflow - Step-by-Step Analytics You can now track consolidated view of users’ workflow journey at each workflow step directly in the workflow graph. Track user entry, exit, drop-offs, branch followed, and node failures. You can also see workflow edit history and compare analytics across different workflow versions and time range. Next up: Deeper analysis into each workflow step - notification engagement (deliver, seen, click), failures, and AI-powered insights. Improvements: Added data centre field in account settings to check where your data centre region. 12 Feb 2025 Batch - Flush First Item Immediately We’ve introduced a new setting in batch processing: Flush First Item in Batch . Previously, batches were only sent once the batch window closed. Now, this setting allows the first trigger to flow past the batch immediately while subsequent triggers are batched within the specified time window. This helps you to build leading debounce logic in workflows, where users are notified immediately about critical updates like anomaly alerts, while other alerts are batched and sent at regular intervals until the issue is resolved. You can find this option in batch -> advanced configuration . 07 Feb 2025 Workflow - Relative Delay and Batch window Added the ability to set relative delays and batch windows in workflows. Previously, delays were fixed or dynamic, with the time difference always being based on the current time. With this update, you can now define delays relative to a future timestamp, often provided by your trigger payload. For instance, send a reminder 30 minutes after a task’s due time or send feedback 5 minutes after an event or webinar. Fixes and Improvements: In Inbox drop-in popover component, we fixed scroll bar causing empty padding UI issue in macOS when Show Scroll bars: Always is enabled. In Inbox drop-in popover component, action menu popup of last notification item was getting cropped. We have fixed this issue. In Inbox drop-in popover component, in mobile view actions menu icon (3 dots icon) only appears on touching notification. After the bug fix, the actions menu icon will appear on all notifications in mobile view by default, removing extra touch interaction. 31 Jan 2025 Nested Objects - Choose the fan out depth Previously, when triggering workflows in nested object hierarchies (where one object subscribes to another), notifications would automatically fan out up to two levels—sending notification to object, its direct subscribers, and child object subscribers. Now, you have full control over how deep the fan-out should go. You can now set the depth in the recipient payload, defining how far the workflow should propagate to fetch subscriptions. 🔹 Depth 0 → Notify only the object’s channels (e.g., Slack team, shared inbox). 🔹 Depth 1 → Notify the object’s channels + direct subscribers. 🔹 Depth N → Expand deeper into hierarchical subscriptions as needed. Copy Ask AI "recipients" : [ { "object_type" : "teams" , "id" : "finance" , //optional parameter to define subscription fan-out depth in workflows "$object_subscriptions_query" : { "depth" : 0 } } ] You can use this to build Escalation Workflows or Tiered Customer Support Notifications , send notification to a shared slack channel or customer support queue first and then escalate to individual users in case of no response in a given time duration. Fixes and Improvements: [SDK] Object methods and User APIs to fetch user and their subscription exposed in Java SDK Added support to trigger multi-lingual templates in broadcast 29 Jan 2025 New handlebars helpers - jsonParse and jsonPath We’ve added handlebars helpers to seamlessly handle JSON strings in the template editor: jsonParse - Converts a JSON string into an object, making it easier to apply conditions or use JSON strings in merge tags. jsonPath - Fetch data corresponding to a path within a JSON object. Works well with jsonParse to directly access nested data in JSON string without block helpers. Fixes and Improvements: Opened up merge tag input to support handlebars helper in email merge tags . Added support for handlebars helper in display condition . 27 Jan 2025 List entry/exit events in trigger You can now trigger a workflow when a user enters or leaves a list. Use this in the Wait Until node to stop reminders or dynamically route users in a workflow on list updates. Earlier, you could achieve the same by enabling event tracking on list updates. Now, you can simply add this logic in workflow without making any changes in list. This will help you build workflows on user lists like, send series of activation notifications to users who didn’t interact with the product in last 30 days and stop sending when they become active again. Fixes and Improvements: [SDK] We have exposed object management methods in Node SDK 20 Jan 2025 Inbox 2.0 - better authentication, In-App feed component and seen interaction Happy to announce a major update in our Inbox SDK. Now, you can directly export and embed In-App feed component and seamlessly create Full screen or Side sheet Inbox experience. What’s New? ✅ Enhanced Security : We’ve replaced HMAC authentication with stateless JWT authentication for better security. ✅ Drop-in components : You can now quickly build an inbox, including full screen and side sheet feeds, by directly importing UI inbox components that are available in our SDK. ✅ Bring your own toast : If you plan to use toast notifications, you have full flexibility to choose any toast library you prefer, allowing you to fully customize the notification experience. These updates offer greater flexibility, security, and customization—giving you full control over your in-app notification experience. If you are on the older SDK version, we recommend you to move on the new version as all future developments will be done on the new SDK. 15 Jan 2025 Interaction Observer: Seen Tracking in Inbox We’re excited to introduce Interaction Observer support in the Inbox, enabling smarter tracking of notification seen state. Now, notifications will be automatically marked as “seen” when they come in user’s scroll view. 10 Jan 2025 Enhanced Broadcast Observability We’ve done a major revamp to our Broadcast logging and monitoring, designed to give you greater control and transparency over your broadcast executions. Here’s what’s new: Real-time Execution Tracking : Monitor broadcast operations as they happen, ensuring you stay informed every step of the way. Step-by-Step Debugging : View detailed execution logs for each step of your broadcast, helping you pinpoint errors and resolve issues faster. Advanced Filters : Quickly locate specific broadcasts with filters for tenant, list ID, broadcast slug, idempotency-key, and status. Easily identify and analyze failure logs. Detailed Broadcast Summaries : Access a comprehensive summary of each broadcast run directly from the listing page, similar to workflow execution logs. 5 Jan 2025 Athena database connector We’ve added Athena to our list of database connectors, enabling you to sync and create dynamic user lists directly from your S3 database. Since Athena can be set up on top of S3, it’s an excellent way to consolidate data from multiple sources and run queries on the unified dataset without the need for complex ETL pipelines. 27 Nov 2024 New workflow node: Invoke Workflow With this update, you can invoke a workflow from within another workflow. This is useful when the recipient list or data context changes between steps in a workflow. A common use case is escalation workflows —e.g., if a team member doesn’t take action within a set time frame, the workflow escalates the issue and notifies their manager. This simplifies complex workflows and supports smooth transitions between related processes, enabling more efficient automation management. 25 Nov 2024 New workflow node: Update User Profile You can now update recipient or actor profiles directly within a workflow. This feature simplifies user profile management by enabling real-time updates as part of the workflow process. If your have event-based system, where user profile changes are coming as events from your product or a third-party system, you don’t need to convert it into user update APIs in your codebase. Simply send events to SuprSend, and let workflows handle user profile updates seamlessly. Key use cases Event-based user profile updates : Simply send events to SuprSend when user updates their profile in your product or when you are setting custom profile attributes as a side-effect of related action, e.g., in a job board, change user’s application status when employer shortlists the profile. Update user profile based on a workflow step : Common use cases include fetching data during the workflow to update the user profile or updating the profile when a user successfully completes a step. For instance, while the onboarding process, update %completion in user profile when they complete a step. 20 Nov 2024 Update Object subscriptions within workflow You can now dynamically update object subscriptions directly within a workflow. This enhancement eliminates the need for separate API calls for object update, allowing you to manage everything seamlessly within workflows. If you have event-based systems where all asset updates are coming in form of event from your product or third-party systems, you don’t have to consume those events internally and write custom APIs to update individual assets (user, list, object) in SuprSend. Simply send events and let the workflow handle object subscriptions and user profile updates, making SuprSend truly a single API integration. Example use case When someone subscribes to a topic (like a tournament), add them as a subscriber to the corresponding tournament object. Later, just trigger tournament related events to SuprSend and the object will automatically fan out and send notification to all users subscribed to the topic. 17 Nov 2024 New workflow node: Add / Remove user in list You can now dynamically update list users as part of workflow execution. This is a step toward creating user segments based on events or workflow progression, removing the need to call the List Update API separately. Key use cases Event-based segmentation : When an event occurs, trigger notification to the user and simultaneously add them to a list for future updates. e.g., when a user registers for an upcoming event or webinar, you can send them confirmation email and add them to a list to later send further updates related to the event. Workflow Step-based segmentation : Another use case is dynamically adding or removing a user from the list when they complete a workflow step. e.g., in a knowledge series designed to onboard new users, remove a user from the POC list once they complete onboarding steps. 15 Nov 2024 Deletion APIs On customer request, added APIs to dynamically delete entities in SuprSend. Following deletion APIs are added: Delete user profile Delete list Delete tenant/brand Delete Object and Remove object subscription These actions are also available on the dashboard for manual management. Delete function just deletes the asset and their related data, including preferences. It doesn’t have any effect on the historical workflows or broadcasts already executed. While calling the delete function, ensure no active workflows are running for the asset, else the execution will fail. 14 Nov 2024 User Merge API: Merge duplicate users into one Happy to announce user merge API to merge duplicate user identities into a single distinct_id . This is helpful to consolidate user profiles, especially when users interact across different products or transition from anonymous to identified states. Key Use Cases Cross-Product Identity Consolidation : When users interact across multiple products (e.g., different apps or services within your platform), they may have different identifiers for each product which needs to be merged later. Anonymous to Identified Transition : Platforms often track user actions anonymously before sign-up or login. During this period, user actions are typically tracked under an anonymous ID. Upon sign-up, merge the anonymous profile into the newly created identifier to preserve historical data and Associate it with the identified user profile. 11 Nov 2024 User Management APIs Being developer first, we have made significant updates and enhancements to the User APIs for easier user management in SuprSend. Also, subscriber is renamed to users in all APIs to avoid confusion with object subscription. Here’s a list of all the changes: Introduced new APIs to fetch user profile , list users and delete user . User update API endpoint has been changed from /event to /user/{{distinct_id}} . There are 2 separate APIs to create(upsert) and edit user profile. Any addition or changes in existing user properties can be done using user upsert API . For deletion of property or channel, user edit API can be used. This is done to keep user upsert API structure flat and simple, consistent to how you identify user in workflow trigger. Subscriber is renamed to user in all APIs, including user preference APIs. 7 Nov 2024 Objects: Design scalable group notifications We’re excited to introduce a powerful new capability in SuprSend: Objects . Objects allow you to manage complex user relationship and notify user groups without identifying individual recipients in your trigger. Ideal for building scalable pub/sub and subscription alerting without having to maintain event to subscriber mapping in your database. You can directly map object-user subscription mapping in SuprSend and SuprSend can efficiently fan-out notifications to thousands of users simultaneously. What You Can Do with Objects: Send notifications to non-user entities like group emails, Slack channels, or shared inboxes (e.g. a Notion feed). Ideal for SaaS applications sending account-level alerts (e.g. anomaly notifications) to shared channels. Objects can have it’s own channels and preferences to handle this use case. Group users by topic or subscription and send them alerts without having to call individual recipients in the trigger . A good example could be SaaS applications managing notifications for end-users, where recipient relationships are coming from a different system, and notification triggers or notification calls are coming from a different system which doesn’t have information of the users subscribed to that trigger. Maintain hierarchical user relationship with nested object subscription . e.g., sending announcements to all the entire team of customer while sending invoice related alerts to finance team. You can handle this by creating object for finance team and then adding it as subscriber to customer object. Objects can be easily tested from platform with all object related actions available on SuprSend console. You can programmatically manage objects from your codebase using rest API calls . Support for SDKs coming soon… If there’s any use case in object that you think is missing and needs to be solved, please reach out to our support . 3 Nov 2024 Datetime comparators in workflow conditions You can now compare datetime fields in workflow conditions . This lets you compare two timestamps where values can be: Variable : computed from workflow input data Static : a fixed timestamp (e.g. 2024-01-01T00:00:00Z ) Relative to current timestamp : e.g. “ now ” or “ now+30d ” (current timestamp +/- interval). Current timestamp is calculated at node runtime and is timezone aware. 30 Oct 2024 Send node execution log - UI revamp The UI for multi-channel and smart routing nodes has been revamped to clearly display how the final list of channels is determined. Now, you get clear visibility into how requested channels in the trigger, override channels, and user and tenant preferences are factored together to compute the final channel list. 29 Oct 2024 Audit Logs To enhance security and transparency, we’ve introduced Audit Trail to help you monitor and track actions happening on your SuprSend console. You can use this to keep track of unwanted or malicious actions in your account. This initial release logs critical account actions along with location and actor details (team member performing the action). You can also filter by team member (actor), specific action or timestamp. Audit logs are available for enterprise users and have customizable retention period. You can find it in account settings. 22 Oct 2024 Support for customizing header component in Inbox Added support for customizing the header component in inbox SDKs. @suprsend/react-inbox You can now add a custom component to the right side of the header in the inbox popup. This replaces the “Mark all as read” text with any JSX you provide. You can even include custom icons, such as settings or preferences, in your JSX and use them to navigate users to specific pages. For an example, refer here . @suprsend/web-inbox In web-inbox , you can add an extra icon beside the “Mark all as read” button at the top of the inbox popup using headerIconUrl . You can also execute custom logic when this icon is clicked using headerIconClickHandler . This feature is useful for cases like displaying settings or preferences icons, which, when clicked, take users to the respective settings or preferences pages. For more information, refer to the documentation. 16 Oct 2024 Sample Workflow Library With the growing number of workflow nodes, we understand that designing the optimal workflow logic can be tricky. That’s why we’ve built out a library of the most-requested, complex workflow samples to make things easier. Now, when you create a new workflow, you can pick from these pre-built samples right within the platform. We’ll continue adding more samples over time—if you have specific use cases, feel free to share them with us at [email protected] , and we’ll add them in the library! 21 Sep 2024 Deprecated Legacy androidpush methods As part of our ongoing efforts to maintain a robust and up-to-date platform, we’ve made the following deprecations: 1. Legacy FCM API Support Due to Google’s shutdown of the legacy Firebase Cloud Messaging (FCM) API, we have removed support for this feature. We strongly recommend migrating to the V1 version of the API that we currently support. For more information, please refer to: Firebase Cloud Messaging Migration Guide 2. Xiaomi Push Service Following Xiaomi’s discontinuation of their push service outside mainland China, we have removed support for this feature. For more information, please visit: Xiaomi Developer Documentation We appreciate your understanding and cooperation as we continue to improve our services. If you have any questions or concerns about these changes, please don’t hesitate to contact our support team. 17 Sep 2024 Subscriber Page Revamp We have revamped subscriber listing page to include relevant information upfront and also, added advanced filtering options on email, phone, active channels, channel count for an entity, and more. All filters are powered by auto-complete search and selectable options, providing you easy access to available filtering options. 14 Sep 2024 Typeahead autocomplete suggestions for subscribers We’re excited to announce a major update to the platform experience with autocomplete in all subscriber search fields. Whether you’re in logs, on the subscriber page, or within testing flows, you can now receive suggestions for existing users without needing to type the full keyword. Autocomplete suggestions are available for distinct_id , email , and phone fields in subscriber profiles. 11 Sep 2024 Inbox - React SDK v3.4.0 This update introduces improvements to action button functionality, enhancing the flexibility and customization options for developers. New Features: Custom Click Handlers: Action buttons now support custom click handlers, allowing developers to execute custom logic when a button is clicked. This update significantly expands the capabilities of action buttons in the Inbox React SDK, providing developers with more tools to create rich, interactive inbox experiences. 8 Sep 2024 Slack Text editor We are happy to announce the support of text editor in slack. So, now you won’t have to write complicated JSONNET template for simple text messages. The text editor supports emoji and use handlebars as the templating language. 6 Sep 2024 Web SDK v2.0 We are excited to announce a major update to our @suprsend/web-sdk . This new version brings significant improvements in security, performance, and developer experience. Major Changes Enhanced Authentication System Replaced workspace key-secret method with public API Key and Signed User JWT token Improved security and access control Synchronous Method Calls All methods now return API call status synchronously Enables better error handling and flow control in applications Improved Code Consistency and Developer Experience Renamed library methods and parameters from snake_case to camelCase Added proper IDE suggestions and method descriptions for easier development Breaking Changes Due to the significant improvements, this version introduces breaking changes. Users upgrading from v1.x should review the migration guide carefully. Documentation For a comprehensive list of changes and migration instructions, please refer to our detailed migration guide For users who need to reference the previous version, v1 documentation is still accessible here Feedback We value your feedback and encourage you to try out the new version. If you encounter any issues or have suggestions for improvement, please don’t hesitate to reach out to our support team. Thank you for your continued support and trust in SuprSend! 4 Sep 2024 View and fetch list users We’ve added a List Users tab to the lists page, giving you direct access to view all users in a list. Being API first, the same functionality is also exposed to API. Refer this GET list users API , or checkout: postman collection . API Details: The API returns 20 users per response. You can retrieve additional users by using cursor-based pagination (before and after cursors). 3 Sep 2024 Better delivery tracking in iOS We are excited to announce significant improvements in our latest update, focusing on enhancing delivery tracking for iOS Push notifications. Regardless of the application’s state, you will now experience more reliable and precise delivery tracking. We have rolled out updates for all our major SDKs. To take full advantage of these improvements, please ensure that you update your dependencies promptly. iOS SDK - v1.0.3 React Native SDK - v2.4.0 Flutter SDK - v2.2.0 2 Sep 2024 Web SDK v1.5.1 We have resolved an issue where the SDK would unexpectedly generate an error message whenever the event payload contained specific emojis. This fix ensures that event processing is now stable and reliable, even when such emojis are present. More details here 30 Aug 2024 Improvement in Workflow Listing page Developer testing workflows are now excluded from the Workflow List Page and search results, ensuring a cleaner and more organized workflow listing. These workflows will still be accessible through logs. Enhanced observability of Tenant APIs by displaying request logs on the logs page. This improvement provides better visibility and monitoring of API interactions. 27 Aug 2024 Wait Until - Add Condition on Event Property We’re excited to announce a powerful update to our Wait Until feature! You can now add multiple events and apply conditions on event properties within the Wait Until branch, allowing for more precise event filtering and targeting of the exact event required in your workflow. This is especially useful for scenarios where the same event triggers multiple workflows, and you want to exit or cancel a notification based on user actions. For instance, in a booking reminder workflow, if a user has multiple bookings, you can now match the booking ID of a cancellation event with the original event to ensure correct reminder gets canceled. Key Changes: Add conditions on event properties using a simple key-operator-value expression (e.g. booking_id = 123 ). Add condition on multiple event properties using AND , OR . Apply conditions across multiple events (e.g. avoid sending a notification if a user completes an action or achieves a specific milestone). Refer documentation for details on how to implement wait until node in your workflow. 26 Aug 2024 Enhanced branching capabilities We are excited to announce significant improvements to our branching capabilities . With the addition of more data types, you can now set precise conditions on various inputs within your branches, such as actor, recipient, and tenant properties. This enhancement allows you to tailor your workflows more effectively, ensuring that each journey is as personalized and efficient as possible. If you haven’t yet explored our branching feature, now is a great time to do so. It offers a robust way to construct multi-step journeys within a single workflow. Here are some example use cases where you could use branch: A/B test notification content by splitting cohorts based on user properties like region. Customize digest schedules (immediate, daily, weekly) using key in your trigger data or recipient’s preference. For support ticket requests, adjust who gets alerts, when to send them (immediately or batched), and which channels to use based on the issue’s priority. Define different next steps in an onboarding checklist depending on a user’s completion percentage. Here, you can also fetch completion% just before sending the next reminder. 23 Aug 2024 New SMS Integration: Pinnacle On customer demand, we are live with latest vendor Integration with Pinnacle for SMS. Check out vendor integration documentation for setup details. 20 Aug 2024 List Details Page Key Improvements: New List Details Page: Access all essential information (logs, broadcast runs, list users) and actions for a list (run broadcast, update user) in a single view, making list management much simpler. “Sync Now” button on query page: This will enable you to manually sync list users when required. Coming Soon: List Users Tab and API: We’ll soon be adding a tab to see all list users. The same functionality will also be exposed to hub APIs to	2026-01-13T08:49:47
https://www.npopov.com/2012/01/09/Disproving-the-Single-Quotes-Performance-Myth.html	Disproving the Single Quotes Performance Myth Blog by nikic . Find me on GitHub , StackOverflow , Twitter and Mastodon . Learn more about me . « Back to article overview. Disproving the Single Quotes Performance Myth 09. January 2012 If there is one PHP related thing that I really hate, then it is definitely the Single Quotes Performance Myth. Let’s do a random Google search for “PHP single quotes performance” : You will get many results telling you that single quotes are faster than double quotes and that string interpolation is much slower than string concatenation. Most of them advise to use single quotes and concatenation to improve the performance of your application. Let’s be clear here: This is pointless. I hold the opinion that microoptimization like that is just pointless. I doubt that string parsing performance is the bottleneck of even a single PHP application out there. This comment nails it pretty well: “And, on top of that, by using less pixels, you reduce greenhouse emissions.” I think that everybody will agree that using single quotes won’t save any significant greenhouse emissions. Still everybody seems to believe that it saves significant execution time. Strange. But okay, some say “Well, it doesn’t cost me anything to write single quotes, so why not just do it?” Sounds plausible. So I decided to look into how big the difference really is. And it turned out: There is none. Strings at runtime What many people don’t realize is that strings are parsed during lexing, not during execution. When a PHP script runs all strings are already parsed. A simple proof: $x = 'Test' ; $y = " \x54\x65\x73\x74 " ; If you have a look at the opcodes that PHP generates for this they will look like this: compiled vars: !0 = $x, !1 = $y line # * op fetch ext return operands --------------------------------------------------------------------------------- 3 0 > ASSIGN !0, 'Test' 4 1 ASSIGN !1, 'Test' 2 > RETURN 1 You don’t need to understand the complete output, but you should still see the main point: Both 'Test' and "\x54\x65\x73\x74" compiled down to the very same opcode. What does this mean? That the used quote type and the use of escape sequences does not affect runtime, not at all. Strings at compile time Now some may argue: PHP is an interpreted language, so compile time actually also happens at runtime. My response to that would normally be: Use APC . APC will cache the generated opcodes so they don’t need to be created on every single request. This can greatly improve page loading time and CPU load, so if you aren’t using APC yet you might try as well now ;) But, hypothetically, let use assume that we are not using APC. So let’s see whether single quoted strings are actually lexed faster than double quoted ones. For this we will use a handy function called token_get_all : It lexes a PHP string into a token array. The function will return the token texts plainly and not preparsed, but the internal string parsing routines still will get called, so we can use this as a good approximation to the real numbers. For testing I use the following script: const NUM = 10000000 ; $singleQuotedStringCode = "<?php '" . str_repeat ( 'x' , NUM ) . "';" ; $doubleQuotedStringCode = '<?php "' . str_repeat ( 'x' , NUM ) . '";' ; $startTime = microtime ( true ); token_get_all ( $singleQuotedStringCode ); $endTime = microtime ( true ); echo 'Single quotes: ' , $endTime - $startTime , ' seconds' , " \n " ; $startTime = microtime ( true ); token_get_all ( $doubleQuotedStringCode ); $endTime = microtime ( true ); echo 'Double quotes: ' , $endTime - $startTime , ' seconds' , " \n " ; It creates two strings with ten million x characters and lexes them. Here’s what I get: Single quotes: 0.061846971511841 seconds Double quotes: 0.061599016189575 seconds Namely: No difference. The Single Quotes Performance Myth thus is just a big lie: Single quotes are neither faster at runtime nor at compile time. String interpolation So the next question is, what is faster: String concatenation or string interpolation? Let’s consider this simple case: $world = 'World' ; 'Hallo ' . $world ; "Hallo $world " ; If you try running the corresponding benchmark you will get numbers similar to this: Concatenation: 0.015104055404663 seconds Interpolation: 0.016894817352295 seconds So interpolation seems slightly slower than concatenation, doesn’t it? Well, not exactly, but more on that later. Let’s look at the opcodes first: compiled vars: !0 = $world line # * op fetch ext return operands --------------------------------------------------------------------------------- 2 0 > ASSIGN !0, 'World' 3 1 CONCAT ~1 'Hallo+', !0 2 FREE ~1 4 3 ADD_STRING ~2 'Hallo+' 4 ADD_VAR ~2 ~2, !0 5 FREE ~2 6 > RETURN 1 Here you see the reason why concatenation is slightly faster than interpolation in the above example: Concatenation uses a single CONCAT opcode with 'Hallo+', !0 ( !0 is $world here). All CONCAT basically does is create a new string buffer with the new length, copy 'Hallo+' into it and then copy $world into it. Interpolation on the other hand needs two opcodes: First ADD_STRING is called, which in this case basically copies 'Hallo+' into a new string buffer. Then ADD_VAR is called with ~2, !0 ( ~2 is the buffer that 'Hallo+' was copied to and !0 is still $world ), which basically does the same as CONCAT . If you read closely the difference is clear: Interpolation copies the 'Hallo+' part twice, concatenation only copies it one time. (Disclaimer: I’m actually not perfectly sure that this is really the reason, but it would be my guess. It could also be just the overhead of another opcode.) So, interpolation is slower after all, isn’t it? Well, not really, let’s consider this more realistic example: $name = 'Anonymous' ; $age = 123 ; $hobby = 'nothing' ; 'Hi! My name is ' . $name . ' and I am ' . $age . ' years old! I love doing ' . $hobby . '!' ; "Hi! My name is $name and I am $age years old! I love doing $hobby !" ; If you run the benchmark you will get numbers looking approximately like this: Concatenation: 0.053942918777466 seconds Interpolation: 0.049801111221313 seconds And… interpolation is faster now! Why so? Let’s have a look at the new opcodes: compiled vars: !0 = $name, !1 = $age, !2 = $hobby line # * op fetch ext return operands --------------------------------------------------------------------------------- 2 0 > ASSIGN !0, 'Anonymous' 3 1 ASSIGN !1, 123 4 2 ASSIGN !2, 'nothing' 6 3 CONCAT ~3 'Hi%21+My+name+is+', !0 4 CONCAT ~4 ~3, '+and+I+am+' 5 CONCAT ~5 ~4, !1 6 CONCAT ~6 ~5, '+years+old%21+I+love+doing+' 7 CONCAT ~7 ~6, !2 8 CONCAT ~8 ~7, '%21' 9 FREE ~8 7 10 ADD_STRING ~9 'Hi%21+My+name+is+' 11 ADD_VAR ~9 ~9, !0 12 ADD_STRING ~9 ~9, '+and+I+am+' 13 ADD_VAR ~9 ~9, !1 14 ADD_STRING ~9 ~9, '+years+old%21+I+love+doing+' 15 ADD_VAR ~9 ~9, !2 16 ADD_CHAR ~9 ~9, 33 17 FREE ~9 18 > RETURN 1 As you can see the interpolation opcodes are more optimal here: For once interpolation distinguishes between adding a single character, a string and a variable. Also it reuses the same temporary variable for the whole interpolation ( ~9 ), whereas concatenation uses six of them ( ~3 , ~4 , ~5 , ~6 , ~7 , ~8 ). So interpolation becomes more efficient the more is interpolated. For the simple string + var case it is slower, but for more realistic cases with multiple variables it becomes faster. Lesson learned At this point I want to emphasize again that the above has no practical impact. All above demos use high iteration counts and any differences in execution time are completely negligible. Does this still teach us something? Yes, it does: “Never trust a statistic you didn’t forge yourself.” Amen. If you liked this article, you may want to browse my other articles or follow me on Twitter or Mastodon .	2026-01-13T08:49:47

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.