Dev Planet

Avatar photo

RSS feed aggregator for FOSS game development.

Schedule for GodotCon 2019 in Poznań

Update 2019-10-16: Here is the current schedule with time table: Link to PDF.

Livesteam of the event is online on YouTube.

As announced a few months back, we are organizing a Godot Conference (GodotCon) in Poznań, Poland next week, on 16 & 17 Oct 2019. We expect close to 90 attendees, so this should be a great event!

Thanks again to the organizers of the Game Industry Conference for hosting us as a pre-GIC event, as well as hosting the Godot Sprint on 14 & 15 Oct at the same venue, where engine contributors will meet to work together, discuss the roadmap for 4.0 and future releases and many other technical topics 🙂

Below you will find the preliminary schedule for GodotCon Poznań, as well as a short description of the talks and the speakers. The order of the talks is still likely to change, and a few more talks may be added as we often get last minute proposals (especially from core contributors who tend to prefer making Pull Requests over preparing talks ;)).

Note for GodotCon attendees: Always refer to the Events page when in doubt about specifics regarding the event (time, location). We’ll update this page in priority whenever there is new details (especially more precise indications about how to find the conference room).

For people who cannot attend GodotCon, do not despair―we plan to have a livestream on Godot’s YouTube channel, which will also be available in replay.

GodotCon schedule

Update 2019-10-16: Here is the current schedule with time table: Link to PDF.

Livesteam of the event is online on YouTube.

Note: This is currently an unordered list of talks we will have. This post will be updated with a plan for when each talk should be in coming days.

  • Demo: Diving into the Vulkan: Presentation and demo of the Godot 4.0 rendering backend | Juan Linietsky (reduz)

    • Juan will show us the current state of the (work-in-progress) Vulkan branch, and explain how it was designed and the main differences with the Godot 3.x backend. He will show new features such as the reworked Global Illumination probes, anisotropy, and how a project like the TPS demo fares on Vulkan.

  • Talk: Creating open games together with Godot | Nathan Lovato (NathanLovato)

    • At GDQuest, we’ve learned to make free software creating small demos, tools, and tutorials for the community. This year was essential for us as we focused on complex projects and learned to work as a team. The next step is to build free and open-source games that both go beyond entertainment and benefit the community. Everyone is welcome to join us on this journey to become better game developers and create meaningful projects together.

  • Talk: GPU procedural map generation in Godot | Paweł Mogila

    • Godot has support for simplex noise and you can generate procedural 2D or even 3D noise with with various parameters. If we use and mix one or more of such noises in proper way you can get nice looking maps. All that happens on the CPU. In my talk I would like to show another approach which uses the GPU for making 2D maps. It’s much faster and we can instantly see the effects as we modify the shader. That gives us much faster iterations and more possibilities.

  • Talk: GDScript coding guidelines at GDQuest | Răzvan Cosmin Rădulescu (razcore-art)

    • Through the nature of Imperative Programming coupled with Object Oriented Programming countless solutions for solving a problem emerge. This flexibility comes with a cost: beginners struggle with knowing where to start while advanced users seek out coding patterns for simplifying their projects, picking the helpful path not necessarily being an easy task. The GDQuest Coding Guidelines have emerged as a “standardized coding layout system” to improve code readability and project workflow by providing a way to think about code structure and object coupling in Godot.

  • Talk: Practical music composition for video games | Pedro J. Estébanez (RandomShaper)

    • This talk will teach the foundations of music composition and will show a workflow by which anyone can create his own instrumental tracks combining that knowledge with the aid of certain software. That’s the exact same workflow the speaker used to create the music for his upcoming game.

  • Demo: My first PR – how to start contributing to Godot | Tomasz Chabora (KoBeWi)

    • Ever wanted to become a Godot contributor, but don’t know where to start? This little guide will show how to identify the cause for a simple issue and make a Pull Request (PR) fixing it, following Godot’s contribution workflow.

  • Talk: WebRTC: Low-latency, encrypted, peer-to-peer multiplayer for Godot Engine | Fabio Alessandrelli (Faless)

    • Overview of the new WebRTC support in the upcoming Godot 3.2: why and how to use it, how it is implemented, etc.

  • Talk: Using Godot for economic simulation and agent-based modelling | Jeremiah Lasquety-Reyes

    • Economic models are difficult to understand for ordinary people. I talk about how Godot can be used for more intuitive and understandable economic models especially through combining a certain school of economics (Austrian economics) and a certain kind of simulation (agent-based modelling). I consider how Godot’s unique scene-node system, flexible graphics, scripting language, and open source code make it a promising alternative to standard agent-based modelling software.

  • Talk: Implementing game programming patterns in Godot | Giovanny Beltrán

    • A software design pattern is a repeatable solution that can be useful in many different scenarios. In this talk, I want to share with you how after developing several games in our studio using Godot, we have started improving our software design practices by implementing design patterns that make coding easier for us while making our games easier to maintain.

  • Demo: Enhance your Godot game with PBD based soft bodies | Leszek Nowak (JohnMeadow1)

    • Leszek will show how to implement various soft bodies using Position Based Dynamics in Godot. Followed by discussion about advantages of using Position Based Dynamics instead of Mass Spring Systems.

  • Talk: Trip the Ark Fantastic | Aleksandar Gavrilović

    • A short presentation of an upcoming Godot based video game called Trip the Ark Fantastic. It is a fable-based RPG cofunded by the MEDIA fund of the European Union which will be released in 2021/2022.

  • Demo: Character rigging using Skeleton2D | Matejs Balodis

    • A quick demo on how to set up, rig and animate a 2D character in Godot Engine using 2D meshes and the Skeleton2D node. In the process you’ll learn some tips and tricks that Matejs has picked up from his experience while creating characters for a stream overlay game.

  • More demos of current and upcoming games by several attendees.

  • Possibly a talk on the FBX support in the upcoming Godot 3.2.

The speakers

Here’s some info about our GodotCon speakers. Note that we’re still accepting late proposals, so you could be one of those too 🙂

Fabio Alessandrelli
Fabio Alessandrelli (Italy) is a core Godot developer and maintainer of the networking stack of the engine, among other contributions. As an indie dev, he also published Aequitas Orbis in early access, a multiplayer 2D space game using Godot 2.1.
Matejs Balodis (Latvia) is a game developer, streamer and member of Rocknight Studios, where the development is done using FOSS tools. He actively promotes Godot Engine and other FOSS tools during livestreams on Twitch by showing viewers the creative process. As part of Rocknight, Matejs hosts a 3-hour game jam every weekend since January 2019 called Trijam, where over 325 games in 40 jams have been created thus far.
Matejs Balodis
Giovanny Beltrán
Giovanny Beltrán (Colombia) is a software engineer with experience working with JavaScript and Python. After working for startups in California, he is now the lead programmer and producer of Black Mamba, an independent game studio located in Bogotá, Colombia, which uses Godot for their projects. He is also co-organizer of BogotaJs, a huge JavaScript meetup in Bogota, co-host of JuegosIndies, a YouTube channel about game design, and just founded a Godot Bogotá meetup.
Tomasz Chabora (Poland) is a passionate game developer and gamer. He is a member of Gamedev Students Association at Jagiellonian University, where he actively promotes Godot engine. He also happens to be an active contributor to the engine, fixing and implementing random stuff.
Tomasz Chabora
Pedro J. Estébanez
Pedro J. Estébanez (Spain) has been involved in different kinds of software development across the years, his main interest and focus regarding computers being multimedia, computer graphics and video game development. He has been contributing to Godot for some years and providing consultancy about it. Currently he’s working on his video game Hellrule.
Aleksandar Gavrilović (Croatia) is the CEO of Gamechuck, a Croatian video game company. Aleksandar previously worked on award winning and critically acclaimed point-and-click adventures, and is now a producer for Trip the Ark Fantastic.
Aleksandar Gavrilović
Jeremiah A. Lasquety-Reyes
Jeremiah A. Lasquety-Reyes (Germany) is a researcher at the Institute for Advanced Study on Media Cultures of Computer Simulation (MECS) at the Leuphana Universität Lüneburg, Germany. Much of his work deals with ethics and medieval philosophy. He plans to use Godot for his upcoming project, the Austrian Economics Model.
Juan Linietsky (Argentina) is Godot’s co-creator and lead developer, and oversees most of the features added to the engine to keep it efficient and well-designed. He splits his work time between writing code himself, and helping other contributors make good changes.
Juan Linietsky
Nathan Lovato
Nathan Lovato (France) is a game creation tutor and free software advocate. With GDQuest, he makes tutorials for programs like Godot and Krita, and releases all his code as source.
Paweł Mogiła (Poland) teaches game programming and motion capture at Jagiellonian University in Krakow. He also creates his own stuff and recently released his last game Clinically Dead on Steam. His next game will be in Godot.
Paweł Mogiła
Leszek Nowak
Leszek Nowak (Poland) teaches Game Development at the Jagiellonian University in Krakow, where they are now using Godot as default teaching software for Simulation and Geometry courses. He also made over 20 games with Godot during game jams.
Răzvan Cosmin Rădulescu (Romania) is a programming freelancer working at GDQuest on creating tools & plugins for FOSS. He’s also the lead developer on GDQuest’s latest 2D platformer game demo. Holds a masters in physics, but slowly drifted away from academia being drawn more by the idea of game development. He also has a keen interest in digital painting & drawing and generally tech-related craft. His latest big dream is to create a highly dynamic community in his (small) home town in Romania, centered around the FOSS philosophy stretching across domains, not just tech.
Răzvan Cosmin Rădulescu
Continue Reading →

Rust GameDev: This Month in Rust GameDev #2 – September 2019

Welcome to the second issue of the Rust GameDev Workgroup’s
monthly newsletter.

Rust is a systems language pursuing the trifecta:
safety, concurrency, and speed.
These goals are well-aligned with game development.

We hope to build an inviting ecosystem for anyone wishing
to use Rust in their development process!
Want to get involved? Join the Rust GameDev working group!

Game Updates 

Veloren 

Town surrounded by a wall

Veloren is an open-world, open-source multiplayer voxel RPG.
The game is in an early stage of development, but is playable.

Some of the September’s improvements:

  • Improved multi-staged towns generation;
  • Improved inventory system and character creation;
  • Massive progress on water, water physics, lakes, and rivers!
  • New chunks data structure;
  • Three-dimensional map and minimap;
  • First-person view;
  • Bows and arrows;
  • Performance optimization;

New video: “24 Minutes of Alpha Gameplay”.

Full weekly devlogs “This Week In Veloren…”:
#31,
#32,
#33,
#34,
#35.

Zemeroth v0.6 

fighters smash demons in fire and poison clouds

Zemeroth is a minimalistic 2D turn-based tactical game.

This month Zemeroth v0.6 was released.
Main features of this release are:

  • renown and fighter upgrades,
  • possessions,
  • sprite frames and flips,
  • status effect icons.

Read the full devlog post or watch the video version.

Twenty Asteroids 

space ship destroys enemies and asteroids with plasma beams

@VladZhukov0 published a few devlogs about their
“Twenty Asteroids” game:

Updates include:

  • New enemies: a ship with a big pinball-like bullet and a laser-mesh ship;
  • New upgrades: laser range and bullets reflection;
  • Explosion size now depends on asteroid’s size;
  • Improved main menu, upgrade and death screens;
  • Better color contrast;
  • New AI behaviors: follow and circle around;
  • Debugging performance plots;

Amethyst Games 

Other Game News 

Library & Tooling updates 

gfx-rs & wgpu-rs: Project Update 

gfx-rs rusty logo

gfx-rs is a Rust project aiming to make low-level GPU programming
portable with low overhead.
It’s a single Vulkan-like Rust API with multiple backends that implement it:
Direct3D 12/11, Metal, Vulkan, and even OpenGL.

wgpu-rs is a Rust project on top of gfx-rs that provides safety,
accessibility, and even stronger portability.

  • gfx-rs was slimmed down: “magical” deps (like failure and derivative)
    were removed and it sped up the fresh gfx-hal build by a factor of 8.5X;
    the “typed” layer of gfx-hal got removed.
  • Backend features were removed from wgpu-rs;
  • An entirely new swapchain model was prototyped and implemented.

Discussions:
/r/rust

Mun and Hot Reloading Experiments 

Mun text logo

Mun is a scripting language for gamedev
focused on quick iteration times that is written in Rust.

Mun’s pillars:

  • Hot Reloading.
    Mun natively supports hot reloading – the process of changing
    code and resources while an app is running –
    on all target platforms and consoles with marginal runtime overhead.
    Its runtime has useful error messages,
    and can easily be embedded into other languages.
  • Static Typing.
    Mun’s type system eliminates an entire class of runtime errors
    and provides powerful IDE integration with
    auto-completion and refactoring tools allowing developers
    to focus on writing code.
  • Performance.
    Mun uses LLVM to compile to machine code that can be natively executed
    on any target platform, guaranteeing the best possible runtime performance.

The driving force behind the development of Mun is natively supported
hot reloading for functions and data.
As such, the language and its syntax will keep growing at the rate
in which hot reloading-supported semantics is added.
Currently, the language looks like this:

fn main() {
    let sum = add(a, b);

    // Comments: Mun natively supports bool, float, and int
    let is_true = true;
    let var: float = 0.5;
}

// The order of function definitions doesn't matter
fn add(a: int, b: int): int {
    a + b
}

The source code of the project
is available on GitHub
under the MIT or Apache licenses.

Mun’s runtime is implemented in Rust.
Check out a GIF demo of the Rust hot reloading functionality
that shows:

  • Catching and logging of errors (e.g. type mismatch),
  • hot reloading of a shared library’s symbols (used for reflection) and method logic,
  • runtime invocable methods and type/method reflection.

Discussions:
/r/rust

Rust Roguelike Toolkit and Roguelike Tutorial 

Minimal pathfinding and FoV example

rltk_rs by @herberticus is a Rust implementation of
C++ Roguelike Toolkit (what is a “roguelike?”).

It provides all the basic functionality one needs to write a roguelike game,
as well as mouse support, an embedded resource system, Web Assembly support,
and more.

All examples are linked to browser WASM to try.

The back-end uses glow to abstract OpenGL between versions.
API for embedding assets directly into your binary.

If you’d like to see a functional roguelike that uses rltk_rs,
check out Rusty Roguelike.

The Roguelike Tutorial includes more than 20 chapters now
and continues to grow.

It covers topics from “hello rust” and “what is an ECS?” to adding monsters,
equipment, nice menus, save/load, multiple levels, bloodstains, particle effects,
magic mapping scrolls, and more.

The tutorial has Web Assembly links to all examples
so you can run them in your browser.

EmbarkStudios/texture-synthesis 

Generated textures samples

Embark has open-sourced their texture synthesis crate texture-synthesis.
It’s an example-based non-parametric image generation algorithm
written in Rust.

The repo also includes multiple
code examples along with test images,
and a compiled binary with a command-line interface
can be found under the release tab.

Also, see a great long recorded talk
“More Like This, Please! Texture Synthesis and Remixing from a Single Example”
which explains this technique and the background more in-depth.

Full list of stuff that Embark has released so far:
embark.rs.

Discussions:
twitter

Also,

Iced – a Renderer-Agnostic GUI Library 

All widgets tour demo: radio buttons, sliders, debugging view, etc

Iced is a renderer-agnostic GUI library focused on simplicity and type-safety.
It was originally born as an attempt at bringing the simplicity of Elm
and The Elm Architecture into Coffee 2D game engine.

Features:

  • Simple, easy-to-use, renderer-agnostic API;
  • Responsive, flexbox-based layouting;
  • Type-safe, reactive programming model;
  • Lots of built-in widgets and custom widget support.

Check out the design overview in the repo’s README.

Discussions:
/r/rust

Amethyst 

amethyst logo

Amethyst is a game engine and tool-set
for ambitious game developers.
It enables game developers to make complex games without getting
into too much trouble, by means of data-driven design
and the ECS architecture.

Tooling:

Godot and Rust 

Recall Singularity's ship base

Tom Leys is working on a “The Recall Singularity” game
about designing autonomous factory ships and stations
and this month they published a few posts
about using the Godot engine with Rust:

Use Prebuilt Rooms with Rust Macros for More Interesting Procedural Dungeons 

Top-down view on a generated dungeon

@whostolemyhat published the fourth part
of their tutorial series on procedural generation with Rust.
In this tutorial, the room generation is updated so it can pick from a selection
of pre-built room patterns as well as create the standard empty room.

Discussions:
/r/rust

Other Library & Tooling News 

Popular Workgroup Issues in Github 

Meeting Minutes 

See all meeting issues including full text notes
or join the next meeting.

Requests for Contribution 

Bonus 

Just an interesting Rust gamedev link from the past. 🙂

a scene with sand, water, a tree, flowers, and fire

Sandspiel is a falling sand game by @MaxBittker
built in late 2018 using Rust (via WASM), WebGL,
and some JS glueing things together.

Sandspiel is a pixel physics simulation sandbox where
you can paint with elements, conduct experiments and build your own world!

Elements include Ice, Water, Sand, Lava, Fire, Oil, Plant, Fungus,
and many more!

The goal was to produce an cellular automata environment that’s
interesting to play with and supports the sharing and forking
of fun creations with other players.
Ultimately, I want the platform to support editing and uploading
of your own elements via a programmable cellular automata API.

The history of the game and the development process are documented in a great
“Making Sandspiel” blog post.

The source code is available on GitHub.

The game’s community is still active: check
@sandspiel_feed feed of uploads.

Discussions:
/r/rust,
/r/programming,
hacker news

That’s all news for today, thanks for reading!

Want something mentioned in the next newsletter?
Send us a pull request.

Also, subscribe to @rust_gamedev on Twitter
or /r/rust_gamedev subreddit if you want to receive fresh news!

Discussions of this post:
/r/rust,
twitter.

Continue Reading →

Libre Arts: Week recap — 24 September 2019

Week highlights: Inkscape 1.0 beta released, GIMP is getting built-in Normal Map filter, Krita team brings more improvements and bugfixes, darktable team is wrapping up v3.0 development, new versions of OBS Studio and Shotcut.

Graphics

It’s been a few interesting weeks over at GIMP and GEGL.

First off, the master branch of GIMP can now optionally be built with Meson thanks to Félix Piédallu. There are more bugs to flesh out, but it basically works. For developers, this decreases local build times. Most users will probably be unaffected.

Ell continued his work on the out-of-canvas feature set, adding an option requested from users — making it possible to preserve canvas padding color instead of using the checkerboard when the Show All option is on. You can either set it on per-image basis or make it used by default.

Michael Natterer and Jehan continued working on plugins API. In particular, Michael started addressing a few 17 years old feature requests asking for a way to make plug-in settings be persistent across sessions and a Reset button. An existing patch for the former is yet to be pushed to the main development branch, the latter already works in the old Despeckle filter used as a testbed.

Another new feature added by Ell is changing compression type for tile swap. It looks puzzling and overly technical until you know what his intention is:

I have a long standing plan of automatically ramping up the compression when you’re running out of swap space, to buy you more time to save everything and regroup 🙂 Right now, this option is there mostly for experimenting/extra control.

Ell also contributed a new GEGL operation, Normal Map, currently sitting in the workshop, which means it’s not yet built by default. Basically it’s because he’s not done with it yet. Some features like filter type choice are still missing.

It’s hard to say if this will make it to GIMP 2.10.4 (if, like me, you build GIMP with workshop enabled, you don’t need to worry). We’ll see.

The Krita team recently released version 4.2.6 mostly with bugfixes (over 120 people participated in beta-testing). Two new features are: ‘New layer from visible’ command now available in layer’s right-click menu, and Angle is now used as the default renderer on Windows.

The master branch is seeing some good action too. Agata Cacko added a simple progress bar for saving KRA files to improve visual feedback. Thanks to Lynx3d, screen color picker can now pick from reference images too. Oh, and Boudewijn Rempt fixed a crapton of resource and memory leaks.

Wolthera continues hacking on SAI files support in a dedicated branch of Krita. Recently, she added some tests to validate correctness of loading the data, then added basic layer style support, basic masks support (more fixes to follow), implemented the Binary blending mode, fixed clipping groups to load correctly, and added support for reading/applying the DPI value.

Inkscape 1.0 beta is finally out! This has been years and years in the making, and it will hopefully soon be completed.

Some of the highlights of the upcoming release are:

  • Optional coordinates origin in top left corner
  • Canvas rotation and mirroring
  • Better HiDPI display support
  • Centerline tracing
  • Tons of live path effects improvements
  • Variable fonts support

MacOS users will also love native UI and signed/notarized .dmg files.

One of the interesting aspects of the beta release is the new multicolor icon theme and advanced theming options.

Basically, the theme is designed around several key colors that can be changed in the Preferences dialog (the red, the green, and the sky blue colors on the screenshot above).

Downloads are up at https://inkscape.org/release/1.0beta1/platforms/.

Photography

The darktable team seems to have started wrapping up writing new code. The next release, v3.0, is likely to be done around winter holidays time.

Aurélien Pierre finally merged tone equalizer, a darktable module he’s been working on for a good part of the year. The module is essentially another take at separating lightness into zones (blacks, shadows, midtones etc.) and adjusting them selectively.

The module has some on-canvas interaction seen on both screenshots: hover over a region that belongs to a zone, then scroll the mouse wheel up or down to adjust EV. Adjacent zone will be compensated for, and unrelated zones won’t be affected at all.

There’s slightly more advanced UI that displays zone and the histogram and allows “painting” right over the EQ curve to tweak it.

For a background information on this feature, there is probably no better source than a dedicated thread over at Pixls.us. (One more important change, filmic v3, is better left for the next weekly report).

Speaking of which, another new fun project is ART, or Another RawTherapee. It’s a friendly fork of the well known photography application, also announced at Pixls.us. Alberto Griggio started it to flesh out some ideas for the original project. He ended up sticking to his fork because of how far the changes went.

So far, Alberto seems more inclined to focus on local editing tools, in particular advanced masking tools, reusing darktable code/ideas where applicable (his tone equalizer is based on an earlier version of the darktable’s module), and streamlining the pipeline to his liking.

Source code is over at BitBucket.

Franco Comida merged the librtprocess integration code into the main development branch of Luminance HDR. If you want to know, how this affects tone mapping in terms of rendering quality, see his old/new previews from a thread on GitHub. The improvement is quite spectacular.

3D and VFX

Blender news are nicely packed in another Blender Live session by Pablo Vazquez:

As usual, more stuff from Pablo Dobarro:

And more:

First appleseed 2.1.0 beta is released, featuring things like OSL shaders compilations on the fly, full support for Cryptomatte, and render checkpointing i.e. resuming multi-pass renders after they were interrupted.

Video

Hugh Bailey et al. finally made a much anticipated new release of OBS Studio, the free/libre video broadcasting and screencasting software. Some of the highlights:

  • Ability to pause recording
  • New option to automatically adjust bitrate instead of dropping frames
  • Ability to select multiple sources on the preview
  • Browser sources can now have their volume adjusted via the audio mixer
  • Fixed hardware acceleration support for decoding media files

Get it from the project’s website.

More than that, Twitch joined NVIDIA and Logitech in sponsoring Hugh’s work on the project and committed to an unannounced annual donation that (it is safe to assume) surpasses 50 grand. The team will also have a booth (first time ever) at TwitchCon 2019 in San Diego.

Dan Dennedy released Shotcut v19.09.14 featuring multi-select for playlist and timeline, new default shortcuts, six new video filters, some other improvements, and a bunch of bugfixes. See the news post for more details.

Matt completed the transform effect in Olive, then went on setting up continuous integration including automatic builds for Windows, macOS, and Linux (AppImage). Hint: you can now grab Windows builds in the Artifacts section at Appveyor, but be warned that it’s alpha quality code. Great new features. But not ready for production yet. But so tempting… And yet… Oh well.

Alexandru Băluț created a merge request for Pitivi, that adds editing nested timelines — a new feature developed by project’s GSoC student Swayamjeet Swain over the summer. It looks like there’s some cleaning up to do before this can be merged.

Not a ton of things going on over at Cinelerra GG, but they recently removed a timebomb placed by Adam Williams over 10 years ago. It made Cinelerra unusable if the currently installed copy was too old (and thus there was a chance that any reportable bugs were already fixed in newer releases).

Meanwhile, Einar Rünkaru is single-handedly working on Cinelerra CVE. Most of the work is low-level under-the-hood stuff, although the keyframable Crop effect sounds end-userish enough to me.

Audio and music

Andrew Belt keeps expanding the ecosystem of VCV Rack. The modular synth now has a separate Chords module which is a quad-note chord sequencer, and you can now write new modules in JavaScript (support for more languages is coming).

Nils Hilbricht et al. announced initial schedule for this year’s Sonoj convention that is taking place on October 26-27 in Cologne, Germany. Some of the topics are JACK, Qtractor, Vital (a new synth), recording sample libraries from acoustic instruments etc.

Tutorials

New Krita timelapse from grafikwork:

New Blender tutorial by Nita Ravalj covers the topic of modeling fur:

Rositsa Zaharieva posted a new the-making-of timelapse for a painting she recently did with Krita.

Inkscape basics with Nick Saporito:

Artworks and showcases

The most impressive, hilarious and god knows what else showcase this past week was an attempt by Grant Wilk to create a microprocessor with Blender. Not model one, actually create one.

Some more information:

Or just follow Grant on Twitter, this is fun!

Atheris Hispida might indeed one of the inspirations for dragons as creatures, as suggested in a BlenderArtists thread for this Cycles render of one, made by

Lucas Falcao posted a few close-ups from his recent personal render that looks like taken out from a very cool animated movie. All done with Blender/Cycles.

Raghavendra Kamath posted another artwork made with Krita:

Marcelo Queiroz‎ has been posting his renditions of DC superheroes on Inkscape‘s Facebook group for a while now, all work done with Inkscape and GIMP:

Continue Reading →