Home  /  Miscellaneous   /  Guest Bloggers   /  Guest Blogger Martijn de Riet: Let me tell you about Revit Families

Guest Blogger Martijn de Riet: Let me tell you about Revit Families

Jared’s Note: As should surprise no one, Kristian’s post comparing ArchiCAD GDL vs Revit Families caused quite a stir on both sides of the ArchiCAD vs Revit divide. I am both thrilled and honored that Martijn de Riet has written a wonderful response to Kristian’s comparison, from the Revit side of things. Martijn is one of my favorite Revit pros on Twitter (more so after reading this post while doing my editing and formatting); he is someone who does a great job of keeping me in line about all things Revit, is very knowledgeable about BIM, and if I’m honest someone who makes me nervous whenever I see he has responded to one of my posts, tweets, etc. Everyday he lives up to his Twitter description of “Brutally honest, straightforward.” I hope between Martijn, Kristian, and all the great commenters, we can all learn a little bit more about our own preferred tools and processes, as well as those that are less familiar to us. Onward to BIM!

A few days ago, Kristian Bursell wrote a post about the differences between Revit Families and ArchiCAD GDL. While I enjoyed reading his post and he was right to a certain degree, there were some things in there that needed a response.

Being biased…

Totally unrelated to the matter, but still highly valuable to sensitive topics: do not EVER say you’re unbiased. Kristian is an ArchiCAD user and consultant with over ten years of experience. I am a Revit user and consultant with almost ten years of experience. I am extremely biased. Totally and utterly biased. There are hardly words to describe how biased I am.

But I am open-minded. And I’m assuming that this is the term Kristian was looking for. I’m not, and I am assuming he’s not either, one of those fundamentalists that has long ago decided everything else is a huge stinking pile of useless garbage.

The second part of me being biased comes from the comparison itself. It’s apples vs oranges. Scripting vs User Interface. And I HATE scripting. I tried it in Revit. It too has the ability to create macros. The Revit API would let you build a family creator that would roughly compare to the Archicad GDL interface. And that interface would have the same abilities to link to external or internal project data. It is another way of creating content in Revit. For instance I am currently checking a Door creator that uses Excel and Access data to create the families.

If you are a visual/graphic kind of guy (like me), having to actually script your families is a nightmare. It changes everything. That too is a form of being biased. We’re men, not machines. We cannot shut down our personal preferences. We can try to keep an open mind, but somewhere in the back of my mind there will always be that little voice saying “what kind of sh*t is this? There has to be a better way!”. And, if I read the post, I can’t help but think that this is written by someone highly familiair with scripting and not with a visual UI to create components. And, as it would with me, that resonates…

Back on topic; I found a few shortcomings in the actual comparison.

It’s bad practice to actually constrain the solid geometry. Good practice would be to create a parametric “framework” of Reference Planes. These are virtual planes or lines inside the family that define the bounding box of a family. These planes are dimensioned and referenced to parameters. The actual geometry is simply locked to these planes and inherits it’s geometrical parameters.

It sounds like a minor detail but in practice it’s crucial to limit the amount of errors and frustrations in family creation. Looking at the images in the post, that’s a fundamental mistake the author made.

For instance, the sink has rounded corners. And its dimensions are constraining the solid sketch. This combination will turn flexing the dimensions into a potential disaster. Good practice would be to add some reference planes and reference lines, dimensioning them and making those flex correctly up front. Then draw the solid and constrain.

File Size

File size isn’t an issue in Revit. It doesn’t necessarily affect model performance. I have tiny families that only consist of 2D representations (<100kb) that take forever to regenerate. I also have highly complex families of over 6mb that work like a charm. The way a family functions is defined by the kind of constraints, levels of nesting and other stuff, not file size. Besides that, when I place a 6mb family and copy it around 1000 times, this hardly affects model performance. All instances reference the same database entry.

The myth about file size originated in the 32bit era. With 64bit machines and limitless amounts of RAM this is no longer an issue.

Drop Down Menus

I very much like the ArchiCAD ability to use drop down menus. In Revit, you can reference other parameters. So Booleans (Yes/No) can be used to drive numerical, other Booleans, and text parameters. It is, in comparison, a rather clumsy way of doing things but will give you the same results. I’ve watched the videos and can safely say I have basically the same families in Revit with the same functionality and options available.

It’s just a different way of doing things. I wouldn’t go as far as saying that it’s less efficient. I don’t know how long it took to create these examples. I also don’t know how skilled you need to be to create them. For me, it would probably take forever and a day in GDL. Not quite so much in Revit.

There is something I can give ArchiCAD major credit for; however you look at it, the ability to create limitative (are they?) dropdowns is a HUGE advantage. Revit families of this kind of complexity need to be very well thought through and documented. And then they will still probably be complete jibberish due to the great amount of parameters and options to anyone that hasn’t studied them very long.

Revit does have one option to create dropdowns: Family Type parameters. These, in combination with nested families, let you “compose” a family out of it’s elements. They have one big advantage: they will pick up any object of the correct type in your project (which means you don’t have to load them all in your family).

They have one big disadvantage: they will pick up any object of the correct type in your project (even the ones completely unrelated).

I would rather be able to define a limited set of options like in ArchiCAD. This can be achieved by using Type Catalogs but still, the ArchiCAD way seems much more efficient and user friendly.

Outside References

Revit does have the ability to reference outside information in the UI, although limited (here come apples vs oranges: when using the coding environment in Revit, it would be the same). There is the option of Type Catalogs (which can be driven from Excel sheets of ODBC-databases). Also their are reporting parameters that you can use in Hosted Families (families that automatically attach themselves to other building components), which infuence the geometric behaviour of the family based on characteristics of it’s host. For instance, the placement or size of a Door Frame hosted in a Wall can adapt to the thickness of that Wall.

Adaptive Component families are the most sophisticated in Revit. They will, as the term specifies, adapt themselves to their environment, thus creating highly flexible families that define their appearance based on their placement in the project. Combined with the option of having text parameters respond to numerical or boolean values creates the possibility of having all kinds of properties respond to geometric differences or changes. The basis for this flexibility is geometry or numeric values. And that is a shortcoming. It’s currently not possible to have the geometry respond to a text value, internal or external.

In older versions of Revit MEP, families could contain csv-files (basic excel-like formatting files) to get all kinds of data. In 2014, this option is expanded to other categories too. I haven’t had the chance to thoroughly test this, but if I’m correct this functionality does let you embed, extract and use all sorts of data from an external source.

Other Topics

I cannot compare Archicad and Revit on Materials and Connections. I do not have the Archicad knowledge. However, I can say that Revit Lighting is not for the faint-hearted, despite (or because) of the ability to reference IES-files. As for the 2D representations: I wouldn’t recommend those. Again, it’s a inherentence from the old days where filesize mattered. Now, it’s just another thing to manage and potentially screw up. There are a few very important aspect of Revit Families that Kristian missed in his post. I can’t blame him; the majority of Revit users greatly underestimate the options available when creating families.

Revit Families are NOT by definition fully defined in a project. If you place a Revit family in a project (for instance a piece of furniture), a few curious things happen:

  1. You can add parameters to the project. These parameters are not in the family, but unique for the project.
  2. Through schedules you can add a thing called Calculated Values. These are parameters that use conditional statements to calculate new things, based on the actual value of the placed instance.
  3. This piece of furniture “knows” which Room it’s in. And this too can be scheduled, along with every parameter of that Room.

The above three things combined mean that, once placed in a project, a Revit Family can inherit properties from other objects (mainly rooms or spaces), perform calculations and/or logical statements and add those properties to the family definition. Out of the box you cannot drive family geometry based on that (although, through the programming interface you can. It’s fairly easy to write a macro that ports this kind of data all over the place. An excellent and free example are the Whitefeet tools).

This is, in my humble opinion, by far the most powerful feature in Revit. Because this brings the ability to have families respond to their surroundings, without the need to actually use the Revit programming interface (did I mention I hate all kinds of code, even C++ or BASIC?)

Revit Family Parts can be turned off and on parametrically.

Every solid you create (or family component you nest) can be turned off and on parametrically. Select it, there will be a “Visible” parameter in the properties. Select the radio button and link this hardcoded property to a Yes/No parameter for control. The Yes/No parameter can then be driven by any formula or conditional statement. In theory, one could have a Window family with all options modelled (sliding, fixed, turning) and turn these options off and on by parameter. Not always a good way to do it though, often a nested component with a Family Type parameter is a better option.

Nested families can inherit properties from their host

Once you start nesting families a great functionality comes into play: the ability to link parameters from “child” to “parent”.

For instance the Window. Let’s say you created the frame and a few infilling panels. You cannot choose the panel based on parameters (which is a big shame). However, the size and position of said panel can be defined by the host parameters. So if I were to have a window family with a checkbox “ventilation grille present” I can do a few things:

  1. Turn a family component on and off that represents a ventilation grille.
  2. Adjust the infilling panel in height so that it automatically leaves room for the ventilation grill or fills up the entire space.

In conclusion

This post isn’t meant to “prove” Revit is better than ArchiCAD. It’s different. Assuming you have enough knowledge, both will get the job done. But I do want to point out the fact that my post will leave truly unbiased readers (such as my dentist or anyone else not working in the AEC industry) with the impression that Revit IS better. As would they think from Kristian’s post that Archicad IS better.

The funny thing with humans is that facts don’t matter, perception does. It’s not about better or worse. Both Revit and ArchiCAD do what you want them to do. But GDL-experts coming from Archicad will always feel more at home with ArchiCAD than with Revit. It’s a different perspective. I will never be comfertable with GDL. It’s a personal preference. The only “real” difference between Revit Families and GDL is scripting vs graphics. The rest is (lack of) knowledge and your point of reference.

The intriguing question is: Assuming that Archicad and Revit are both equally capable and assuming that the only real limitation to what you can do is knowledge and training, does this mean that your choice in BIM software should be based on your preference in the User Interface? Is the real question here whether you’re a scripting or a graphics person? Does the debate about which software is better eventually boil down to “nurture vs nature”?

Jared’s Note: You know my answer to that last question: YES. Though I also have a hunch the scripting vs graphics POV might look different as we explore various aspects of the two programs. And I think that’s great. Thank you again to two BIM pros that I greatly respect. Martijn and Kristian favor different tools, have strong opinions, and I’m so happy to be able to share their counter views here on Shoegnome. So what topic is next? What aspect should we ask some pros of different BIM software to talk about? There’ll be some mine is better than yours talk, but of course we’re going to lean towards the tool we prefer. That’s fine. I just want to learn more about all the solutions. Maybe we can find a Vectorworks or Bentley Systems pro to talk about how they handle Object making? That’d be cool. Anyone know we should ask? Oh and follow Shoegnome on FacebookTwitter, and the RSS feed.


(Martijn’s post is longer than anything else I’ve posted on Shoegnome, but I didn’t want to break it up and it’s full of so much good info. So below are some more thoughts that I felt could be moved to the end for hardcore readers. Enjoy!)

As I’m writing this, there are currently 3 comments to Kristian’s post (Stefan Boeykens is the last one). In response to Ben Cohen, Kristian writes:

“The equivalent of editable hotspots in Revit are what they call Handles. You can assign rules to them but i’m told (by a “Power” Revit User) it once again affect file size. Also its restricted to the properties of the element whose handle you are using as to how it can move. As far as I know you cant really assign the levels of control we do with hotspots for altering configurations as well as general sizes. I’m thinking of the rotating hotspot you have/had on your window tool to change an opening from sliding to casement to double hung, or even something simple like the positioning of a downpipe in a length of gutter in a roof edging GDL Object; not possible in Revit.”

Not entirely true. Shape Handles are purely geometric and only work in certain ways. As a building engineer I detest them, basically because you lose control over the outcome (a Door width of 759.4mm is a nightmare). I usually create my families in such a way that they don’t work. Except when the family’s nature calls for them off course (for instance a gutter which should be flexible by definition). Having shape handles however does give you the ability to lock a Family geometry to other building elements and have it flex automatically. But, contrary to general element file size, that DOES hugely affect model performance.

Changing openings from sliding to casement to double is generally done by using nested components. The Door/Window infill is a nested component. Add more infill families to your project and you can choose from a Dropdown menu which one you would want to use. Or add it to the type catalog.

About the position of a downpipe in a roof gutter: sure that’s possible. Want it to be a certain distance from the side? Want that distance to flex based on the length of the gutter? Want that distance to be a numeric value? All relatively easy to do. As is the amount of downpipes based on the total length of the gutter, the length of the downpipe based on the height of the gutter, and so on. IMHO this is a fine example of the “information bias” talking.


  • August 15, 2013


    Thankyou for taking the time to respond with a thorough post, I enjoyed it and did actually learn a little bit. Please note that the questions I ask below do not come with tongue in cheek; I do actually like RFA’s and enjoy working with them, I merely what to know how to push the envelope.

    You mentioned API’s for creating Graphical Users Interfaces and said it would roughly compare to the GDL GUI; the truth is the GUI you can create with an API is far more advanced then the GUI in GDL objects (heads up Graphisoft; we want more friendly GUI tools). However we can also create API’s for ArchiCAD in the same way. Many powerful ArchiCAD tools started off as 3rd party API’s and the list continues to grow. Check out the suite of tools from Cadimage (http://www.cadimage.com/) for some good examples, especially their cladding tools, or have a look at this video (http://www.youtube.com/watch?v=8NL0hL_KMqY).

    In “shortcomings” you state constraints are bad practice; I agree they work poorly. Reference planes are definitely a better solution and a good way to organize your variables and limit errors. However, to achieve the same functionality as GDL I would have to create a veritable maze of reference planes with complex formulas in the constraining dimensions to other reference planes. In GDL I put a formula into the value of a part of an element, simple, straight-up, efficient and highly adaptive.

    I’m glad to hear what you say about file size it puts a lot of those concerns to bed and means I am free to make my families as complex as I like. Would I be correct in assuming the total size of loaded families would affect the opening and possibly saving of a project?

    I would be very keen to see the families you mentioned that have basically the same functionality as the objects in the videos in my post. I do not doubt you I just really really want to see it.

    Your information on reporting parameters and adaptive component families is encouraging, and I will definitely have to play around with it more. However from what I have tested the list of properties that can be reported is not very long. Door frames should adapt to the thickness of the wall, this cannot be considered I high powered function. Is there somewhere a list of the properties that can be reported?

    With Type Catalogues can you link a parameter to any cell of the Excel sheet or does not the sheet need to be configured to the family’s parameter list?

    Your 3 points in “Other Topics” are very interesting. I’m aware of project parameters and must say I’m a huge fan, especially when configuring wall systems and alike. To achieve the same in ArchiCAD we have to create a Property Object (through GDL) and then assign it to components individually. Though the assignment is made efficient through certain functions, there is still huge potential for error. The one good thing about Property objects is that you can assign formulas to the parameters defined. I assume this is like a combination or your points 1 and 2. However I expect Revit project parameters can also have formulas, so it probably still has the upper hand.

    The fact that a piece of furniture knows which room it is in is nothing special, in fact it should be expected. What would be impressive is if you can tie that data into the parameters of the family so that it responds. Something we do in ArchiCAD is to create a parameter in doors that automatically detects if the door is in a fire passage and then restricts the door configuration to fire passage compliance. Can this be done in RFA’s?

    I like the “Visible” parameter for controlling the appearance of sub elements, though I get frustrated that I can still see the element when building the family; can this be adjusted? I also like the detail level function in RFA’s; assigning fine, medium, or course filters is cool. In ArchiCAD we use a resolution control which is far more efficient for simplifying geometry but it is not a global function and you have to make sure your equations allow for the lower end resolutions.

    Most of your conclusion is very true, especially your comment on perception. Fundamentally we are beings of perception, and this perception is based on the culmination of all our experiences. However we can transcend our perception if we have the patience.

    With all due respect; your comment on the only “real” difference being scripting vs graphics, with the rest being (lack of) knowledge, is the one extremely ignorant comment in your post. Unless you know GDL you are not qualified to make such a statement, and I can tell you the statement is completely wrong. Its makes people thing GDL is hard and RFA’s easy but both as powerful as each other; the actual truth is very different. GDL scripting makes the creation of powerful aspect of objects very easy, while some aspects that should be basic in RFA’s are down right difficult or impossible. This only applies to some aspects in both platforms; the opposite could also be said when comparing other functions.

    Your retort on my downpipe comment doesn’t answer the question. Editable hotspots in GDL allow us to push and pull all aspects of a model to very rapidly configure the element in the 3D or plan view; check the videos (http://cadswift.com.au/products/Swift-Gutter-Plus.html).

    To me ArchiCAD and Revit are both mine, and soon to Bentley I hope. I use them both daily and want the creators to give me what I ask for; so I point out the good and bad in both. There is no perception issue here, it’s about efficiency and power, and for that reason I am glad I know GDL. It’s a stepping stone to API’s and ultimate potential. However, I want Graphisoft to add many of the functions in RFA’s though a graphical creation process in not one of them. This may baffle some people but that is because you don’t know GDL. A graphical creation interface would not make me more efficient because there are too many powerful properties in the definition of GDL geometry and my particular use of equations for the creation of geometry would be lost: you may as well cut off my right hand.

    All in all a good post with only minor failures. Could you please take the time to provide links to examples confirming your comments, so we can truly learn.

    • August 19, 2013

      Hi Kristian,

      Nice to hear you thoughts.

      First of all: I probably wasn’t clear enough. I’m not just biased, I’m also completely ignorant towards Archicad. I have no knowledge whatsoever about Archicad. And especially not about GDL, except from what I read in your post and found during some quick google searches.

      I’m not quite sure what you mean with the part about “creating a veritable maze of reference planes”. I’ve never had the need of creating more reference planes then there is geometry (solids). You are spot on about complex formulas though, those can get really ugly.

      About file size: it can affect model performance, but not necessarily. Although I do hear a general consensus that the Archicad model performance is better and smoother then Revit.

      A few examples of highly parametric families can be found here: http://www.revit-content.com/all-in-one/. Video tutorials can be found here: http://www.youtube.com/user/revitcontent. These are not mine, but have the advantage that they aren’t under a Non-Disclosure Agreement either…
      By the way: I don’t advocate the use of these families. These get highly complex, and I don’t see the situation where I go “I know I initially put in a single turning door, but silly me, I actually wanted a 6 panel bifold door”… But that’s just me.

      About the reporting parameters: you’re right, the list isn’t very long. However, with some creativity using the Wall thickness for door placement is the least you can do (keep in mind though: before this feature was added a few years ago, it wasn’t possible to do so!). However, this does take some training. It’s not an easy or well documented solution. Afaik only length, area or volume parameters can be reporting.
      Adaptive Components can be seen as the next step in this development. These have more responsive capabilities and more “options”. (which would result in another lengthy post to fully describe. Instead I would just like to point you to buildz.blogspot.com)

      About Type Catalogs: not quite sure what you mean here? A type catalog is a simple txt-file. This can be generated from the family and might be tied to another xls or odbc dataset. But the txt-file needs to have certain columns (with parameters you want to fill) and a certain layout.

      Revit project parameters can’t hold formula’s. Calculated Values can.
      Therefor a door configuration cannot change depending on the wall it’s in. Not in the UI anyway. Funny thing is that in the API it’s fully available. Just not in the UI… Great example of this weird behaviour is the To/From Room parameter in Doors: in the API this is a dynamically changing parameter, in the UI it’s a static one that doesn’t update if you flip the door.

      It’s not possible to change the visibility of elements you set to not being Visible in the Family Editor. Not automatically though. However, you can simply select them and temporarily hide them using the goggle icon (or right mouse-click).

      Which brings me to the “ignorant” part: I’m sorry, but you seem to misunderstand my point here. GDL’s are in essence a scripting solution. I can write an Addon for Revit that has the same functionality (well, I can’t cause my lack of programming skills, but there are some out there that come close). Which would have the funny effect that some of the GDL-scripting strength would be suddenly available. For example the ability to create geometry based on some coordinates or having a door adjust to fire rating values of the hosted wall.. And some UI Revit plusses would suddenly be not available.

      My point was: the way the problem of modelling complex families is approached, UI vs scripting, defines the strengths and weaknesses of the solution.

      Now whether I like or dislike any given solution is based on (lack of) knowledge and personal preference. I still stand by that for two reasons:
      1. I’m sorry, but I simply have a hard time believing people to be equally skilled in multiple platforms without bias or preference. It’s simply not possible in my very humble opinion. Both Archicad and Revit are such complex and extensive pieces of software that it’s simply not something you master in just 20 hours a week. And to be honest: there are parts of both your post and your comment that really “feel” like you’re not so skilled as you are with GDL. For instance the Archicad Hotspots: these are the same as the Revit grip handles (google “Revit grip handles”). Which you would have known about if you were equally skilled as in Archicad
      (Be aware: not trying to bash your skills, just giving an example on how lack of knowledge “colors” your perception. It’s something you missed, which is entirely cool. But still…)

      btw: just for clarity, in your comment you stated “or even something simple like the positioning of a downpipe in a length of gutter in a roof edging GDL Object; not possible in Revit.” This is what I was referring too: set the downpipe refplanes to strong reference, use instance parameters for all geometry definitions and here come all the grips.
      Do I use it? No. Why not? Because a downpipe return angle isn’t 38,73 degrees. It’s 30 or 45 or 60. Period. Having the ability to flex the angle doesn’t add value for me (again, that’s just being me).
      As for the length of the gutter: use a line-based family and you can simply click on the roof edge. The gutter will by definition adjust to changing edge lengths.

      2. I specifically adressed the fact that people might think from my post that Revit is easy and Archicad/GDL is hard. And that this isn’t the case. Really don’t know how explicit I need to be on that one?
      What I’m saying is that you might consider GDL easy and powerful, that’s only the case assuming I know or want to know how to write any code. I’m just saying: that’s a big assumption and might be a bridge too far for a lot of people. I’m a visual kind of guy. Having me dabble in a coding environment is like cutting off my left hand.
      Funny thing: I only started using Type Catalogs after Autodesk gave us the option to create a Type Catalog from the family editor. Before that, it was too much of a hassle to get the syntax correct! Just to give you an idea of my inability to work with computer languages…

  • August 15, 2013

    Great articles… both of them. Biased, yes, but nonetheless constructive and critical in a positive way.
    The only down side is like in other forums/blogs, it seems that every response starts escalating in aggressiveness.
    I hope later replies prove me wrong.
    I wonder – Jared, If I could offer you my point of view of the software comparison in a short post like this. Is entirely up to you to publish it or not.


    Nando Mogollon
    ArchiCAD AND Revit user

    • August 15, 2013

      Nando, definitely! Pull together your thoughts and send me the post via e-mail. And I agree, we all are very passionate about this topic. So it’s easy to turn a little rebuke into something bigger than it was meant to be. Fortunately though there is great respect among all the participants. At the end of the day, I know we can all forgive each other for getting a little riled up. And look past the stray grumpy comment amidst so much awesome conversation.

  • August 18, 2013

    1. Constraints: I dont think Revit’s constraint solving system is really discussed properly here. Not having a constraints system in AC is a major limitation. ‘Constraining’ a prism or block’s length to a Ref plane/line Revit-style is slightly different to ‘constraining’ one cell to another in Excel, where the parameter is passed/referenced.. which is more like what GDL, not having constraints solving.


    Revit’s geometric constraints solving is a lot more powerful… even it causes the model to slow. On balance, it would be better to have it than not, especially for the early design phases…. and suppress/strip them off as the model gets bigger.

    GDL also suffers ‘structurally’ from not incorporating separate ‘Reference’ geometry into its basic data set. I think this is due to its ‘text based’ beginnings when computing power was limited. OTOH, the level of integration/exposure of this text-based approach is pretty powerful.

    2. Relationships: as mentioned AC seems to be lacking here. AC/GDL is great stack-based ‘3d Postscript’ that can (re)generate a complex models based on small text files… as long as there are isolated/discrete. It will need to get ‘chatty’ and ‘branch-predictive’ like Revit… in future. It wil be interesting to see if it can do this without the big smarts that Revit is proud of which must be a big part of the reason that it is still a hog to use.


    3. Nature v Nuture or Graphical v Scripting: We need both!! It should/need not be either or. This Sony v BetaMax stuff is tired/unhelpful. See Robert Woodbury’s Elements of Parametric Design, p66, which references Myers Hudson Pausch (2000) “Past, Present and Future of User Interface Software Tools”.

    AC is going from text-based and getting more and more graphic all the time. AC lost a lot of users because its longstanding reputation for forcing the designers to work through the dailog box (as sophisticated as it is). What ever happened to Zoom GDL?

    GDL doesn’t nest other GDL objects very well compared to Revit. OK, you can use those ‘get/set’ functions

    CALL macro_name_string [,]
    PARAMETERS [ALL][name1=value1, … namen=valuen][[,]


    but I can see this running into spaghetti code problems very quickly. Type checking by user? Revit is more of a ‘nanny state’ here, but I think this is necessary evil.

    Especially when dealing with hosting/nesting or connections, both staples of building object behaviours / BIM. AC12’s Curtain Wall tool is based on something called System Technologies which was supposed to address this and next-gen GDL… is it accesible from GDL? Allplan’s SmartParts is also based on GDL and has some next gen hotspots…. hopefully in AC18.

    GDL needs a proper IDE…. maybe something like Vasari’s Relationship Viewer:


    Even pro coders have graphical interfaces, intellisense etc… why be a monk in GDL?


    4.AFAIK, GDL has no splines/NURBS commands. I suspect it will end up like Revit’s AdaptiveComponents. A lot of the simplicity that allows GDL to work with polygonal geometry will struggle with 3d splines etc. There will be a lot more complex transforms etc that will be difficult to understand without a GUI.

Post a Comment