LEGO SNOT Techniques: What Are They & How to Use Them

Trusted by Over 392 Clients

Custom model

LEGO SNOT techniques have become popular very quickly, this is because the method introduces a new way to get the best out of your LEGO® building experience and achieve more details that would not have been ordinarily possible following the more traditional approach to the building. But what exactly is involved in this technique? Are there illegal SNOT techniques? What are the advantages and disadvantages of these techniques? We will cover all of this and more in this blog post.

What Does SNOT Mean?

SNOT means ” Studs not on top ” and is a technique of placing brick Stud pieces on the side or upside down, other than the conventional placement on the top of each brick piece.

You might be wondering why this style is gradually becoming very popular among LEGO® fanatics worldwide. This is because this new method offers builders the right to be more creative and explore different types of builds.

This method also allows builders to design new sets that you could not achieve with the conventional building techniques offered by LEGO.

The SNOT method also offers LEGO® builders the room to manipulate their LEGO® pieces and achieve unheard-of designs, but all this is not the main reason people go for this method.

They go for this unique technique because there are no limits or restrictions to what you can achieve using this technique, the only limitation is your imagination.

So as far as you can see it happen, it’s achievable with this LEGO® set. But what exactly is involved in achieving this technique? And are there any illegal SNOT techniques? Let’s find out as we progress.

Tools You Need to Achieve the LEGO® SNOT Technique

Well, not much is needed to achieve this LEGO® building technique. All you need are a lot of different LEGO® sets to play with, your imagination, and YouTube for an extra juice of creativity.

When trying to achieve this building technique for the first time, it may seem to be a bit challenging, but with the help of the internet and your will and determination, you will be able to produce something truly spectacular.

With this technique, you could achieve impossible builds like a ladder, the human skull, and other challenging designs.

Imagine a scenario that seems very difficult to build using the LEGO® conventional building methods, then try using different techniques. Remember, the SNOT technique involves unconventionally manipulating the stud place.

So don’t be shy to get a little creative!

Well, some people wonder if any SNOT techniques are illegal. Let’s find out in the next section.

Illegal LEGO® SNOT Building Techniques

As far as SNOT techniques go, there are no limit to what you can achieve using the method. But some plans have been considered illegal by the LEGO® team.

One of those techniques involves using an external source or cord to connect Stud pieces. Another technique that has been deemed unlawful is clicking flatter pieces sideways on top of the Stud to make use of the available Stud hole openings in the details provided.

Note, though, that the illegality of these LEGO® SNOT techniques only prevents them from using these techniques in official LEGO® sets, they have to stick with LEGO® usable building techniques… but you don’t!

These now bring us to the main points we emphasized throughout the beginning of this post. You are the only limit to how far you take your LEGO® SNOT technique. But what are the pros and cons of using the SNOT technique? Let’s find out.

Pros and Cons of the LEGO® SNOT Technique

Disadvantages of the LEGO® SNOT Technique

As far as disadvantages go, there are not many you would find whilst using this technique. The only real proven drawback is that there’s not a complete manual that tells you exactly what to do and how when it comes to LEGO® SNOT techniques.

This makes it challenging for those seeking to venture into this technique, but then again, some people might not see this as a disadvantage because as LEGO® builders are notorious for using our hands and brains to figure out how to make cool designs.

Advantages of the LEGO® SNOT Technique

The SNOT technique holds a lot of advantages.

You have a free hand to manipulate your LEGO® bricks to achieve whatever designs you desire.

Another advantage is converting sets originally designed one way into something different. You could even enhance a sets original form, adding in more details or features.

There is no limit, which is the true advantage of this particular technique. Another LEGO® Theme that works very effectively with the LEGO® SNOT technique is using the LEGO® Technic brick pieces.

Can the LEGO® SNOT Technique Be Used With Technic?

Most people wonder if the SNOT technique is compatible with LEGO® Technic pieces. If you are a beginner and looking for a way to venture into this type of building technique, LEGO® Technic would be an excellent place to start.

Pieces from this set offer you multiple ways to be able to manipulate them in different positions to achieve different styles and designs.

You need to think of the type of style you would like and allow your imagination to lead the way.

Using LEGO® Technic pieces would help you better master the SNOT building style. But what are some examples of LEGO® SNOT techniques? Let’s find out.

Examples of LEGO® SNOT Techniques

LEGO SNOT Can Be Used for Stability

One technical way LEGO® SNOT can be used is to increase your designs stability. Sometimes when building sideways, it could be challenging to gain strength and this is when the LEGO® SNOT techniques are perfect.

You could Use gain stability by locking some of your SNOT pieces in place, giving you maximum stability when building. This technique could be beneficial for beginners finding it challenging to provide their structural stability using this technique.

LEGO SNOT as Reversals

Sometimes when we build, we might want to change the direction our set is taking. LEGO® SNOT techniques makes the reversal process effortless and more neatly achieved.

This technique is mainly needed when you have two connected ends. the method would make this connection very easy.

LEGO SNOT & the Void

Many LEGO® parts have spaces, specifically arches, that might seem challenging to use if you don’t build studs on top. To unlock their full potential, technical use of SNOT is sometimes required. You can also accomplish this on a smaller footprint for microscale or architectural details.

This is an example from one of your buildings, a space freighter probably. The detailing of the holes is accomplished with 2+4 added to Technic bricks in the center, which could then slide into the space under the arches to make a complex subassembly.

LEGO SNOT With Stop and Wedge

Let’s get a little more advanced.

In the geometry of the LEGO® system, lots of slopes and wedges have close angles.

You can use this not-so-random coincidence to create smooth transitions in more angular situations. For example, a smooth transition is achieved with a 45-degree cut out slope on brackets.

Another example is attaching standard pitches to headlight bricks (one is disconnected so you can better notice the interior) to match the geometry of the white element on top. You can achieve all this with the LEGO® SNOT method.

SNOT Text

Speaking of clips and bars, did you know that you can use the LEGO® SNOT techniques to build textual signs.

To be completely transparent, there is no easy way of doing this as several letters will always be challenging to achieve, challenging but not always impossible.

An honourable mention of SNOT is Perhaps LEGO’s Modular series. Both 10284 pet shop and10224 townhall used the clip and bar technique to create letters out of flat elements.

Complex SNOT: Trapping

Sometimes, it might feel impossible to get the exact result you want, especially when the geometry of studs gets in the way. There is a method that can help you in these instances, this is called Trapping.

Trapping is when you arrange parts locked in place, even though they are not connected. That way, you can build nearly any geometry you want.

We have two prime examples of the technique – the build by Ryan Howerter and the right build by Tyler Cities. If you check out those two examples, you will know exactly what I mean.

LEGO SNOT is a fun way to upgrade your building experience no matter the set. so once you get your hands on your next set make sure to try the SNOTing technique.

ferdivol

<div class="badge-base LI-profile-badge" data-locale="en_US" data-size="large" data-theme="dark" data-type="HORIZONTAL" data-vanity="ferdi-vol" data-version="v1"><a class="badge-base__link LI-simple-link" href="https://www.linkedin.com/in/%E2%9C%85-ferdi-vol-corporate-gifts/?trk=profile-badge"></a></div>

/* Auto generated, hash = 5dceu9kevqjdyuy2uw1atqrsu */
//TODO: Break this file down so that we can actually unit test it.
(function(window) {
  /**
  * Renders all unrendred LinkedIn Badges on the page
  */
  window.LIRenderAll = function () {
    var CALLBACK_NAME     = 'LIBadgeCallback', //Must match callback on helpers.js
        BADGE_NAMES       = '.LI-profile-badge, .LI-entity-badge',
        // TODO -- tracking param for other badge types
        TRACKING_PARAM    = 'profile-badge',
        responsesReceived = 0, //Keeps track of number of responses recieved for proper cleanup when finished
        expectedResponses = 0, //Keeps track of number of responses to expect
        scripts           = [ ], //Keeps track of scripts added for proper cleanup when finished
        childScripts      = {}, //Keeps track of child scripts to render
        badges            = Array.prototype.slice.call(document.querySelectorAll(BADGE_NAMES));

    var i, len, badge, rendered;
    for (i = 0, len = badges.length;  i < len; i++) {
      badge    = badges[i];
      rendered =  badge.getAttribute('data-rendered');
      if (!rendered) {
        expectedResponses++;
        badge.setAttribute('data-rendered', true);
        renderBadge(badge);
      }
    }

    function isCNDomain() {
      if (typeof window !== "undefined") {
        var hostName = window.location && window.location.hostname ||  '';
        return (/linkedin(-ei)?.cn$/).test(hostName);
      }

      return false;
    }

    function generateUrl(isEI) {
      var domainPrefix = isEI ? 'https://badges.linkedin-ei' : 'https://badges.linkedin';
      if (isCNDomain()) {
        return domainPrefix + ".cn/";
      }

      return domainPrefix + ".com/";
    }

    function getBadgeKeyQueryParams(badge) {
      return Array.prototype.slice.call(badge.attributes).filter(function (attr) {
        return attr.name.lastIndexOf('data-key-', 0) !== -1;
      }).map(function (attr) {
        // Most browsers automatically lowercase the attribute name when its being read
        // We are calling lowercase on it again to ensure consistency for any browsers that are lagging behind.
        return encodeURIComponent(attr.name.replace('data-', '').toLowerCase()) + '=' + encodeURIComponent(attr.value);
      });
    }

    /*
    * Renders a single badge on the page
    * @param badge: div element of badge to render
    */
    function renderBadge(badge) {
      var size       = badge.getAttribute('data-size'),
          locale     = badge.getAttribute('data-locale'),
          type       = badge.getAttribute('data-type'),
          theme      = badge.getAttribute('data-theme'),
          vanity     = badge.getAttribute('data-vanity'),
          version    = badge.getAttribute('data-version'),
          isEI       = badge.hasAttribute('data-ei'),
          entity     = badge.getAttribute('data-entity'),
          isCreatePage = badge.hasAttribute('data-iscreate'),
          uid        = Math.round(1000000 * Math.random()),
          baseUrl = generateUrl(isEI),
          queryParams = [
            'locale=' + encodeURIComponent(locale),
            'badgetype=' + encodeURIComponent(type),
            'badgetheme=' + encodeURIComponent(theme),
            'uid=' + encodeURIComponent(uid),
            'version=' + encodeURIComponent(version)
          ],
          url;

      if (version === 'v2') {
        baseUrl += 'view';
        queryParams.push('badgesize=' + encodeURIComponent(size));
        queryParams.push('entity=' + encodeURIComponent(entity));
        queryParams = queryParams.concat(getBadgeKeyQueryParams(badge));
      } else {
        baseUrl += 'profile';
        queryParams.push('maxsize=' + encodeURIComponent(size));
        queryParams.push('trk=' + encodeURIComponent(TRACKING_PARAM));
        queryParams.push('vanityname=' + encodeURIComponent(vanity));
      }

      if (isCreatePage) {
        queryParams.push('fromCreate=true');
      }

      url = baseUrl + '?' + queryParams.join('&');
      badge.setAttribute('data-uid' , uid);
      jsonp(url); //Calls responseHandler when done
    }

    /**
    * Handles a response from the server. Finds badge matching badgeUid and inserts badgeHtml there
    * @param badgeHtml: String representing contents of the badge
    * @param badgeUid: UID of the badge to target
    **/
    function responseHandler(badgeHtml, badgeUid) {
      responsesReceived ++;

      var i, badge, uid, isCreate;
      var defaultWidth = 330 // max possible width
      var defaultHeight = 300 // max possible height

      for (i = 0, len = badges.length; i < len; i++) {
        badge = badges[i];
        // isCreate needed to prevent reloading artdeco script tag
        isCreate = badge.getAttribute('data-iscreate');
        uid   = parseInt(badge.getAttribute('data-uid'), 10);
        if (uid === badgeUid) {
          var badgeMarkup = `<body>${badgeHtml}</body>`
          var iframe = document.createElement('iframe');
          iframe.onload = function() {
            var iframeBody = iframe.contentWindow.document.body;
            // 5 px buffer to avoid the badge border being cut off.
            iframe.setAttribute('height', (iframeBody.scrollHeight || defaultHeight) + 5);
            iframe.setAttribute('width', (iframeBody.scrollWidth || defaultWidth) + 5);
          };
          iframe.setAttribute('frameBorder', '0');
          iframe.style.display = 'block';
          badge.appendChild(iframe);
          iframe.contentWindow.document.open();
          iframe.contentWindow.document.write(badgeMarkup);
          iframe.contentWindow.document.close();
          replaceScriptTags(badge, isCreate);
        }
      }
      tryClean();
    }

  // These functions are needed because badge markup is added via innerHtml property which does not run script tags
  function replaceScriptTags(node, isCreate) {
    if (shouldReplaceNode(node, isCreate)) {
      node.parentNode.replaceChild(cloneScriptNode(node), node);
      childScripts[node.src] = true;
    } else {
      var i = 0,
          children = node.childNodes;
      while (i < children.length) {
        replaceScriptTags(children[i++], isCreate);
      }
    }
    return node;
  }

  function shouldReplaceNode(node, isCreate) {
    return isScriptNode(node) && !childScripts[node.src] && (!isCreate || (isCreate && !node.getAttribute('data-isartdeco')));
  }

  function isScriptNode(node) {
    return node.tagName === 'SCRIPT';
  }

  function cloneScriptNode(node){
    var script  = document.createElement("script");
    for( var i = node.attributes.length-1; i >= 0; i-- ) {
      script.setAttribute( node.attributes[i].name, node.attributes[i].value );
    }
    return script;
  }

    // Gets all incoming responses
    window[CALLBACK_NAME] = responseHandler;

    /**
    * Tries to clean added tags
    **/
    function tryClean() {
      //Clean up after all requests are done..
      //Accounts for people including script more than once
      var done = (responsesReceived >= expectedResponses && expectedResponses > 0) || responsesReceived >= badges.length;
      if (done) {
        delete window[CALLBACK_NAME];

        // remove all script tags
        scripts.map(function(script){
          document.body.removeChild(script);
        });

      }
    }

    /*
    * Makes Jsonp request, responses handles by CALLBACK_NAME
    * @param url String: url of server to make request to
    */
    function jsonp(url) {
      var script = document.createElement('script');
      script.src = url;
      scripts.push(script);
      document.body.appendChild(script);
    }
  };

  if (document.readyState === 'complete') {
    window.LIRenderAll();
  } else {
    window.addEventListener('load', window.LIRenderAll, false);
  }

})(window);